Multiple computer architecture with synchronization

ABSTRACT

The present invention discloses a modified computer architecture ( 50, 71, 72 ) which enables an applications program ( 50 ) to be run simultaneously on a plurality of computers (M 1 , . . . Mn). Shared memory at each computer is updated with amendments and/or overwrites so that all memory read requests are satisfied locally. During initial program loading ( 75 ), or similar, instructions which result in the application program ( 50 ) acquiring (or releasing) a lock on a particular asset ( 50 A,  50 X- 50 Y) (synchronization) are identified. Additional instructions are inserted ( 162, 163 ) to result in a modified synchronization routine with which all computers are updated.

FIELD OF THE INVENTION

The present invention relates to computers and, in particular, to amodified machine architecture which enables the operation of anapplication program simultaneously on a plurality of computersinterconnected via a communications network.

BACKGROUND ART

Ever since the advent of computers, and computing, software forcomputers has been written to be operated upon a single machine. Asindicated in FIG. 1, that single prior art machine 1 is made up from acentral processing unit, or CPU, 2 which is connected to a memory 3 viaa bus 4. Also connected to the bus 4 are various other functional unitsof the single machine 1 such as a screen 5, keyboard 6 and mouse 7.

A fundamental limit to the performance of the machine 1 is that the datato be manipulated by the CPU 2, and the results of those manipulations,must be moved by the bus 4. The bus 4 suffers from a number of problemsincluding so called bus “queues” formed by units wishing to gain anaccess to the bus, contention problems, and the like. These problemscan, to some extent, be alleviated by various stratagems including cachememory, however, such stratagems invariably increase the administrativeoverhead of the machine 1.

Naturally, over the years various attempts have been made to increasemachine performance. One approach is to use symmetric multipleprocessors. This prior art approach has been used in so called “super”computers and is schematically indicated in FIG. 2. Here a plurality ofCPU's 12 are connected to global memory 13. Again, a bottleneck arisesin the communications between the CPU's 12 and the memory 13. Thisprocess has been termed “Single System Image”. There is only oneapplication and one whole copy of the memory for the application whichis distributed over the global memory. The single application can readfrom and write to, (ie share) any memory location completelytransparently.

Where there are a number of such machines interconnected via a network,this is achieved by taking the single application written for a singlemachine and partitioning the required memory resources into parts. Theseparts are then distributed across a number of computers to form theglobal memory 13 accessible by all CPU's 12. This procedure relies onmasking, or hiding, the memory partition from the single runningapplication program. The performance degrades when one CPU on onemachine must access (via a network) a memory location physically locatedin a different machine.

Although super computers have been technically successful in achievinghigh computational rates, they are not commercially successful in thattheir inherent complexity makes them extremely expensive not only tomanufacture but to administer. In particular, the single system imageconcept has never been able to scale over “commodity” (or mass produced)computers and networks. In particular, the Single System Image concepthas only found practical application on very fast (and hence veryexpensive) computers interconnected by very fast (and similarlyexpensive) networks.

A further possibility of increased computer power through the use of aplural number of machines arises from the prior art concept ofdistributed computing which is schematically illustrated in FIG. 3. Inthis known arrangement, a single application program (Ap) is partitionedby its author (or another programmer who has become familiar with theapplication program) into various discrete tasks so as to run upon, say,three machines in which case n in FIG. 3 is the integer 3. The intentionhere is that each of the machines M1 . . . M3 runs a different third ofthe entire application and the intention is that the loads applied tothe various machines be approximately equal. The machines communicatevia a network 14 which can be provided in various forms such as acommunications link, the internet, intranets, local area networks, andthe like. Typically the speed of operation of such networks 14 is anorder of magnitude slower than the speed of operation of the bus 4 ineach of the individual machines M1, M2, etc.

Distributed computing suffers from a number of disadvantages. Firstly,it is a difficult job to partition the application and this must be donemanually. Secondly, communicating data, partial results, results and thelike over the network 14 is an administrative overhead. Thirdly, theneed for partitioning makes it extremely difficult to scale upwardly byutilising more machines since the application having been partitionedinto, say three, does not run well upon four machines. Fourthly, in theevent that one of the machines should become disabled, the overallperformance of the entire system is substantially degraded.

A further prior art arrangement is known as network computing via“clusters” as is schematically illustrated in FIG. 4. In this approach,the entire application is loaded onto each of the machines M1, M2 . . .Mn. Each machine communicates with a common database but does notcommunicate directly with the other machines. Although each machine runsthe same application, each machine is doing a different “job” and usesonly its own memory. This is somewhat analogous to a number of windowseach of which sell train tickets to the public. This approach doesoperate, is scalable and mainly suffers from the disadvantage that it isdifficult to administer the network.

In computer languages such as JAVA and MICROSOFT.NET there are two majortypes of constructs with which programmers deal. In the JAVA languagethese are known as objects and classes. In any computer environment itis necessary to acquire and release a lock to enable the use of suchassets, resources or structures to avoid different parts of theapplication program attempting to use the same resource at the one time.In the JAVA environment this is known as synchronization. This isachieved in JAVA by the “monitor enter” and “monitor exit” instructionsor routines. Other languages use different terms but utilize a similarconcept.

The present invention discloses a computing environment in which anapplication program operates simultaneously on a plurality of computers.In such an environment it is necessary to ensure that the “monitorenter” and “monitor exit” (more generally synchronization routines)operate in a consistent fashion across all the machines. It is this goalof consistent locking of resources that is the genesis of the presentinvention.

In accordance with a first aspect of the present invention there isdisclosed a method multiple computer system having at least oneapplication program running simultaneously on a plurality of computersinterconnected by a communications network, wherein a like plurality ofsubstantially identical objects are created, each in the correspondingcomputer and each having a substantially identical name, and said systemincluding a lock means applicable to all said computers wherein anycomputer wishing to utilize a named object therein acquires anauthorizing lock from said lock means which permits said utilization andwhich prevents all the other computers from utilizing theircorresponding named object until said authorizing lock is relinquished.

In accordance with a second aspect of the present invention there isdisclosed a plurality of computers interconnected via a communicationslink and operating at least one application program simultaneouslywherein each said computer in operating said at least one applicationprogram utilizes an object only in local memory physically located ineach said computer, the contents of the local memory utilized by eachsaid computer is fundamentally similar but not, at each instant,identical, and every one of said computers has a an acquire lock routineand a release lock routine which permit utilization of the local objectonly by one computer if each of the remainder of said plurality ofcomputers is locked out of utilization of their corresponding object.

In accordance with a third aspect of the present invention there isdisclosed a method of running at least one application program on aplurality of computers simultaneously, said computers beinginterconnected by means of a communications network, said methodcomprising the steps of:

-   (i) creating a like plurality of substantially identical objects    each in the corresponding computer and each having a substantially    identical name, and-   (ii) requiring any of said computers wishing to utilize a named    object therein to acquire an authorizing lock which permits said    utilization and which prevents all the other computers from    utilizing their corresponding named object until said authorizing    lock is relinquished.

In accordance with a fourth aspect of the present invention there isdisclosed a method of ensuring consistent synchronization of anapplication program to be run simultaneously on a plurality of computersinterconnected via a communications network, said method comprising thesteps of:

-   (i) scrutinizing said application program at, or prior to, or after    loading to detect each program step defining an synchronization    routine, and-   (ii) modifying said synchronization routine to ensure utilization by    only one computer of an object and preventing all the remaining    computers from simultaneously utilizing their corresponding objects.

In accordance with a fifth aspect of the present invention there isdisclosed a multiple thread processing computer operation in whichindividual threads of a single application program are simultaneouslybeing processed each on a corresponding one of a plurality of computersinterconnected via a communications link, and in which objects in localmemory physically associated with the computer processing each threadhave corresponding objects in the local memory of each other saidcomputer, the improvement comprising permitting only one of saidcomputers to utilize an object and preventing all the remainingcomputers from simultaneously utilizing their corresponding object.

In accordance with a sixth aspect of the present invention there isdisclosed a computer program product comprising a set of programinstructions stored in a storage medium and operable to permit aplurality of computers to carry out the abovementioned methods.

BRIEF DESCRIPTION OF THE DRAWINGS

Embodiments of the present invention will now be described withreference to the drawings in which:

FIG. 1 is a schematic view of the internal architecture of aconventional computer,

FIG. 2 is a schematic illustration showing the internal architecture ofknown symmetric multiple processors,

FIG. 3 is a schematic representation of prior art distributed computing,

FIG. 4 is a schematic representation of a prior art network computingusing clusters,

FIG. 5 is a schematic block diagram of a plurality of machines operatingthe same application program in accordance with a first embodiment ofthe present invention,

FIG. 6 is a schematic illustration of a prior art computer arranged tooperate JAVA code and thereby constitute a JAVA virtual machine,

FIG. 7 is a drawing similar to FIG. 6 but illustrating the initialloading of code in accordance with the preferred embodiment,

FIG. 8 is a drawing similar to FIG. 5 but illustrating theinterconnection of a plurality of computers each operating JAVA code inthe manner illustrated in FIG. 7,

FIG. 9 is a flow chart of the procedure followed during loading of thesame application on each machine in the network,

FIG. 10 is a flow chart showing a modified procedure similar to that ofFIG. 9,

FIG. 11 is a schematic representation of multiple thread processingcarried out on the machines of FIG. 8 utilizing a first embodiment ofmemory updating,

FIG. 12 is a schematic representation similar to FIG. 11 butillustrating an alternative embodiment,

FIG. 13 illustrates multi-thread memory updating for the computers ofFIG. 8,

FIG. 14 is a schematic illustration of a prior art computer arranged tooperate in JAVA code and thereby constitute a JAVA virtual machine,

FIG. 15 is a schematic representation of n machines running theapplication program and serviced by an additional server machine X,

FIG. 16 is a flow chart of illustrating the modification of the monitorenter and exit routines,

FIG. 17 is a flow chart illustrating the process followed by processingmachine in requesting the acquisition of a lock,

FIG. 18 is a flow chart illustrating the requesting of the release of alock,

FIG. 19 is a flow chart of the response of the server machine X to therequest of FIG. 17,

FIG. 20 is a flow chart illustrating the response of the server machineX to the request of FIG. 18,

FIG. 21 is a schematic representation of two laptop computersinterconnected to simultaneously run a plurality of applications, withboth applications running on a single computer,

FIG. 22 is a view similar to FIG. 21 but showing the FIG. 21 apparatuswith one application operating on each computer, and

FIG. 23 is a view similar to FIGS. 21 and 22 but showing the FIG. 21apparatus with both applications operating simultaneously on bothcomputers.

The specification includes Annexures A and D which provide actualprogram fragments which implement various aspects of the describedembodiments. Annexure A relates to fields and Annexure D tosynchronization.

DETAILED DESCRIPTION

In connection with FIG. 5, in accordance with a preferred embodiment ofthe present invention a single application program 50 can be operatedsimultaneously on a number of machines M1, M2 . . . Mn communicating vianetwork 53. As it will become apparent hereafter, each of the machinesM1, M2 . . . Mn operates with the same application program 50 on eachmachine M1, M2 . . . Mn and thus all of the machines M1, M2 . . . Mnhave the same application code and data 50. Similarly, each of themachines M1, M2 . . . Mn operates with the same (or substantially thesame) modifier 51 on each machine M1, M2 . . . Mn and thus all of themachines M1, M2 . . . Mn have the same (or substantially the same)modifier 51 with the modifier of machine M2 being designated 51/2. Inaddition, during the loading of, or preceding the execution of, theapplication 50 on each machine M1, M2 . . . Mn, each application 50 hasbeen modified by the corresponding modifier 51 according to the samerules (or substantially the same rules since minor optimising changesare permitted within each modifier 51/1 . . . 51/n).

As a consequence of the above described arrangement, if each of themachines M1, M2 . . . Mn has, say, a shared memory capability of 10 MB,then the total shared memory available to each application 50 is not, asone might expect, 10 n MB but rather only 10 MB. However, how thisresults in improved operation will become apparent hereafter. Naturally,each machine M1, M2 . . . Mn has an unshared memory capability. Theunshared memory capability of the machines M1, M2 . . . Mn are normallyapproximately equal but need not be.

It is known from the prior art to operate a machine (produced by one ofvarious manufacturers and having an operating system operating in one ofvarious different languages) in a particular language of theapplication, by creating a virtual machine as schematically illustratedin FIG. 6. The prior art arrangement of FIG. 6 takes the form of theapplication 50 written in the Java language and executing within a JavaVirtual Machine 61. Thus, where the intended language of the applicationis the language JAVA, a JAVA virtual machine is created which is able tooperate code in JAVA irrespective of the machine manufacturer andinternal details of the machine. For further details see “The JAVAVirtual Machine Specification” 2^(nd) Edition by T. Lindholm & F. Yellinof Sun Microsystems Inc. of the USA.

This well known prior art arrangement of FIG. 6 is modified inaccordance with the preferred embodiment of the present invention by theprovision of an additional facility which is conveniently termed“distributed run time” or DRT 71 as seen in FIG. 7. In FIG. 7, theapplication 50 is loaded onto the Java Virtual Machine 72 via thedistributed runtime system 71 through the loading procedure indicated byarrow 75. A distributed run time system is available from the OpenSoftware Foundation under the name of Distributed Computing Environment(DCE). In particular, the distributed runtime 71 comes into operationduring the loading procedure indicated by arrow 75 of the JAVAapplication 50 so as to initially create the JAVA virtual machine 72.The sequence of operations during loading will be described hereafter inrelation to FIG. 9.

FIG. 8 shows in modified form the arrangement of FIG. 5 utilising JAVAvirtual machines, each as illustrated in FIG. 7. It will be apparentthat again the same application 50 is loaded onto each machine M1, M2 .. . Mn. However, the communications between each machine M1, M2 . . .Mn, and indicated by arrows 83, although physically routed through themachine hardware, are controlled by the individual DRT's 71/1 . . . 71/nwithin each machine. Thus, in practice this may be conceptionalised asthe DRT's 71/1 . . . 71/n communicating with each other via the network73 rather than the machines M1, M2 . . . Mn themselves.

Turning now to FIGS. 7 and 9, during the loading procedure 75, theprogram 50 being loaded to create each JAVA virtual machine 72 ismodified. This modification commences at 90 in FIG. 9 and involves theinitial step 91 of detecting all memory locations (termed fields inJAVA—but equivalent terms are used in other languages) in theapplication 50 being loaded. Such memory locations need to be identifiedfor subsequent processing at steps 92 and 93. The DRT 71 during theloading procedure 75 creates a list of all the memory locations thusidentified, the JAVA fields being listed by object and class. Bothvolatile and synchronous fields are listed.

The next phase (designated 92 in FIG. 9) of the modification procedureis to search through the executable application code in order to locateevery processing activity that manipulates or changes field valuescorresponding to the list generated at step 91 and thus writes to fieldsso the value at the corresponding memory location is changed. When suchan operation (typically putstatic or putfield in the JAVA language) isdetected which changes the field value, then an “updating propagationroutine” is inserted by step 93 at this place in the program to ensurethat all other machines are notified that the value of the field haschanged. Thereafter, the loading procedure continues in a normal way asindicated by step 94 in FIG. 9.

An alternative form of initial modification during loading isillustrated in FIG. 10. Here the start and listing steps 90 and 91 andthe searching step 92 are the same as in FIG. 9. However, rather thaninsert the “updating propagation routine” as in step 93 in which theprocessing thread carries out the updating, instead an “alert routine”is inserted at step 103. The “alert routine” instructs a thread orthreads not used in processing and allocated to the DRT, to carry outthe necessary propagation. This step 103 is a quicker alternative whichresults in lower overhead.

Once this initial modification during the loading procedure has takenplace, then either one of the multiple thread processing operationsillustrated in FIGS. 11 and 12 takes place. As seen in FIG. 11, multiplethread processing 110 on the machines consisting of threads 111/1 . . .111/4 is occurring and the processing of the second thread 111/2 (inthis example) results in that thread 111/2 becoming aware at step 113 ofa change of field value. At this stage the normal processing of thatthread 111/2 is halted at step 114, and the same thread 111/2 notifiesall other machines M2 . . . Mn via the network 53 of the identity of thechanged field and the changed value which occurred at step 113. At theend of that communication procedure, the thread 111/2 then resumes theprocessing at step 115 until the next instance where there is a changeof field value.

In the alternative arrangement illustrated in FIG. 12, once a thread121/2 has become aware of a change of field value at step 113, itinstructs DRT processing 120 (as indicated by step 125 and arrow 127)that another thread(s) 121/1 allocated to the DRT processing 120 is topropagate in accordance with step 128 via the network 53 to all othermachines M2 . . . Mn the identity of the changed field and the changedvalue detected at step 113. This is an operation which can be carriedout quickly and thus the processing of the initial thread 111/2 is onlyinterrupted momentarily as indicated in step 125 before the thread 111/2resumes processing in step 115. The other thread 121/1 which has beennotified of the change (as indicated by arrow 127) then communicatesthat change as indicated in step 128 via the network 53 to each of theother machines M2 . . . Mn.

This second arrangement of FIG. 12 makes better utilisation of theprocessing power of the various threads 111/1 . . . 111/3 and 121/1(which are not, in general, subject to equal demands) and gives betterscaling with increasing size of “n”, (n being an integer greater than orequal to 2 which represents the total number of machines which areconnected to the network 53 and which run the application program 50simultaneously). Irrespective of which arrangement is used, the changedfield and identities and values detected at step 113 are propagated toall the other machines M2 . . . Mn on the network.

This is illustrated in FIG. 13 where the DRT 71/1 and its thread 121/1of FIG. 12 (represented by step 128 in FIG. 13) sends via the network 53the identity and changed value of the listed memory location generatedat step 113 of FIG. 12 by processing in machine M1, to each of the othermachines M2 . . . Mn.

Each of the other machines M2 . . . Mn carries out the action indicatedby steps 135 and 136 in FIG. 13 for machine Mn by receiving the identityand value pair from the network 53 and writing the new value into thelocal corresponding memory location.

In the prior art arrangement in FIG. 3 utilising distributed software,memory accesses from one machine's software to memory physically locatedon another machine are permitted by the network interconnecting themachines. However, such memory accesses can result in delays inprocessing of the order of 10⁶-10⁷ cycles of the central processing unitof the machine. This in large part accounts for the diminishedperformance of the multiple interconnected machines.

However, in the present arrangement as described above in connectionwith FIG. 8, it will be appreciated that all reading of data issatisfied locally because the current value of all fields is stored onthe machine carrying out the processing which generates the demand toread memory. Such local processing can be satisfied within 10²-10³cycles of the central processing unit. Thus, in practice, there issubstantially no waiting for memory accesses which involves reads.

However, most application software reads memory frequently but writes tomemory relatively infrequently. As a consequence, the rate at whichmemory is being written or re-written is relatively slow compared to therate at which memory is being read. Because of this slow demand forwriting or re-writing of memory, the fields can be continually updatedat a relatively low speed via the inexpensive commodity network 53, yetthis low speed is sufficient to meet the application program's demandfor writing to memory. The result is that the performance of the FIG. 8arrangement is vastly superior to that of FIG. 3.

In a further modification in relation to the above, the identities andvalues of changed fields can be grouped into batches so as to furtherreduce the demands on the communication speed of the network 53interconnecting the various machines.

It will also be apparent to those skilled in the art that in a tablecreated by each DRT 71 when initially recording the fields, for eachfield there is a name or identity which is common throughout the networkand which the network recognises. However, in the individual machinesthe memory location corresponding to a given named field will vary overtime since each machine will progressively store changed field values atdifferent locations according to its own internal processes. Thus thetable in each of the DRTs will have, in general, different memorylocations but each global “field name” will have the same “field value”stored in the different memory locations.

It will also be apparent to those skilled in the art that theabovementioned modification of the application program during loadingcan be accomplished in up to five ways by:

-   (i) re-compilation at loading,-   (ii) by a pre-compilation procedure prior to loading,-   (iii) compilation prior to loading,-   (iv) a “just-in-time” compilation, or-   (v) re-compilation after loading (but, or for example, before    execution of the relevant or corresponding application code in a    distributed environment).

Traditionally the term “compilation” implies a change in code orlanguage, eg from source to object code or one language to another.Clearly the use of the term “compilation” (and its grammaticalequivalents) in the present specification is not so restricted and canalso include or embrace modifications within the same code or language.

In the first embodiment, a particular machine, say machine M2, loads theapplication code on itself, modifies it, and then loads each of theother machines M1, M3 . . . Mn (either sequentially or simultaneously)with the modified code. In this arrangement, which may be termed“master/slave”, each of machines M1, M3, . . . Mn loads what it is givenby machine M2.

In a still further embodiment, each machine receives the applicationcode, but modifies it and loads the modified code on that machine. Thisenables the modification carried out by each machine to be slightlydifferent being optimized based upon its architecture and operatingsystem, yet still coherent with all other similar modifications.

In a further arrangement, a particular machine, say M1, loads theunmodified code and all other machines M2, M3 . . . Mn do a modificationto delete the original application code and load the modified version.

In all instances, the supply can be branched (ie M2 supplies each of M1,M3, M4, etc directly) or cascaded or sequential (ie M2 applies M1 whichthen supplies M3 which then supplies M4, and so on).

In a still further arrangement, the machines M1 to Mn, can send all loadrequests to an additional machine (not illustrated) which is not runningthe application program, which performs the modification via any of theaforementioned methods, and returns the modified routine to each of themachines M1 to Mn which then load the modified routine locally. In thisarrangement, machines M1 to Mn forward all load requests to thisadditional machine which returns a modified routine to each machine. Themodifications performed by this additional machine can include any ofthe modifications covered under the scope of the present invention.

Persons skilled in the computing arts will be aware of at least fourtechniques used in creating modifications in computer code. The first isto make the modification in the original (source) language. The secondis to convert the original code (in say JAVA) into an intermediaterepresentation (or intermediate language). Once this conversion takesplace the modification is made and then the conversion is reversed. Thisgives the desired result of modified JAVA code.

The third possibility is to convert to machine code (either directly orvia the abovementioned intermediate language). Then the machine code ismodified before being loaded and executed. The fourth possibility is toconvert the original code to an intermediate representation, which isthen modified and subsequently converted into machine code.

The present invention encompasses all four modification routes and alsoa combination of two, three or even all four, of such routes.

Turning now to FIG. 14, there is illustrated a schematic representationof a single prior art computer operated as a JAVA virtual machine. Inthis way, a machine (produced by any one of various manufacturers andhaving an operating system operating in any one of various differentlanguages) can operate in the particular language of the applicationprogram 50, in this instance the JAVA language. That is, a JAVA virtualmachine 72 is able to operate code 50 in the JAVA language, and utilizethe JAVA architecture irrespective of the machine manufacturer and theinternal details of the machine.

Furthermore, the single machine of FIG. 14 is able to easily performsynchronization of specific objects 50X-50Z when specified by theprogrammer's use of a synchronization routine. As each object existsonly locally, the single JAVA virtual machine 72 of FIG. 14 is able toensure that an object is properly synchronized as specified by theprogrammer and thus only utilized by one part of the executable code atany single point in time. If another part of the executable code wishesto use the same object then the possible contention is resolved by theJAVA virtual machine 72 such that other executing parts of theapplication program have to wait until the first part has finished.

The same procedure applies mutatis mutandis for classes 50A. Inparticular, the computer programmer when writing a program using theJAVA language and architecture, need only to use a synchronizationroutine(s) in order to provide for this avoidance of contention. Thus asingle JAVA virtual machine can keep track of utilization of the classesand objects and avoid any corresponding problems as necessary in anunobtrusive fashion. The process whereby only one object or class isexclusively used is termed “synchronization”. In the JAVA language theinstructions “monitorenter” and “monitorexit” signify the beginning andending of a synchronization routine which results in the acquiring ofand releasing of a “lock” respectively which prevents an asset being thesubject of contention.

However, in the arrangement illustrated in FIG. 8, (and also in FIGS.20-22), a plurality of individual computers or machines M1, M2 . . . Mnare provided each of which are interconnected via a communicationsnetwork 53 and each of which is provided with a modifier 51 (as in FIG.5 and realized by the DRT 71 in FIG. 8) and loaded with a commonapplication program 50. Essentially the modifier 51 or DRT 71 ensuresthat when part of the application program 50 running on one of themachines exclusively utilizes (eg, by means of synchronization) aparticular local asset, such as an objects 50X-50Z or class 50A, noother machine M2 . . . Mn utilizes the corresponding asset in its localmemory.

In particular, whilst one particular machine (say, M3) is exclusivelyusing an object or class, another machine (say M5) may also beinstructed by the code it is executing to exclusively use that object orclass at that time. Thus if the object or class were to be exclusivelyused by both machines, then the behaviour of the object and applicationas a whole is undefined—that is, in the absence of proper exclusive useof an object when explicitly specified by the programmer, permanentinconsistency between machine M5 and machine M3 is likely to result.Thus the goal of substantially identical memory contents for each of themachines M1, M2 . . . Mn, as required for simultaneous operation of thesame application program, would not be achieved.

In order to ensure consistent synchronization the application program isscrutinized in order to detect program steps which define asynchronization routine. This scrutiny can take place either prior toloading, or during the loading procedure, or even after the loadingprocedure (but before execution of the relevant corresponding portion ofthe application code). It may be likened to a compilation procedure withthe understanding that the term compilation normally involves a changein code or language, eg from source to object code or one language toanother. However, in the present instance the term “compilation” (andits grammatical equivalents) is not so restricted and can also includeembrace modifications within the same code or language.

Reference is made to the accompanying Annexure D in which:

-   Annexure D1 is a typical code fragment from an unmodified    synchronization routine, and-   Annexure D2 is an equivalent in respect of a modified    synchronization routine,

Annexures D1 and D2 are the before and after excerpt of asynchronization routine respectively. The modified code that is added tothe method is highlighted in bold. In the original code sample ofAnnexure D1, the code increments a shared memory location (counter)within in synchronize statement. The purpose of the synchronizestatement is to ensure thread-safety of the increment operation inmulti-threaded applications. Thus, without management of synchronizationin a distributed environment, each machine would perform synchronizationin isolation, thus potentially incrementing the shared counter at thesame time, leading to potential race condition(s) and incoherent memory.Clearly this is not what the programmer of the application programexpects to happen.

So, taking advantage of the DRT, the application code is modified as itis loaded into the machine by changing the synchronization routine. Thechanges made (highlighted in bold) are the initial instructions anderiding instructions that the synchronization routine executes. Theseadded instructions act to additionally perform synchronization acrossall other machines in the distributed environment, thereby preservingthe synchronize behaviour of the application program across a pluralityof machines.

The acquireLock( ) method of the DRT takes an argument which representsa unique identifier for this object (See Annexure D2), for example thename of the object, a reference to the object in question, or a uniquenumber representing this object across all nodes, to be used inacquiring a global lock of the specified object. This way, the DRT cansupport the synchronization of multiple objects at the same time withoutbecoming confused as to which of the multiple objects are alreadysynchronized and which are not, by using the unique identifier of eachobject to consult the correct record in the shared synchronizationtable.

The DRT can determine the synchronization state of the object in anumber of ways. Preferably, it can ask each machine in turn if theirlocal copy of this object is presently synchronized, and if any machinereplies true, then to wait until that object is unsynchronised,otherwise synchronize this object locally. Alternatively, the DRT on thelocal machine can consult a shared record table (perhaps on a separatemachine (eg machine X), or a coherent shared record table on the localmachine, or a database) to determine if this object has been marked assynchronized by any other machine, and if so, then wait until the statusof the object is changed to “unsynchronised” and then acquire the lockby marking the object as synchronized, otherwise acquire the lock bymarking the object as synchronized by this machine.

If the DRT determines that no other machine currently has a lock forthis object (ie, no other machine has synchronized this object), then toacquire the lock for this object on all other machines, for example bymeans of modifiying the corresponding entry in a shared table ofsynchronization states, or alternatively, sequentially acquiring thelock on all other machines in addition the current machine. Only oncethis machine has successfully confirmed that no other machine hascurrently synchronized this object, and this machine has correspondinglysynchronized locally, can the execution of the original synchronizedcode-block begin.

On the other hand, if the DRT determines that another machine hasalready synchronized this object, then this machine is to postponeexecution of the original synchronize code-block until such a time asthe DRT can confirm than no other machine is presently executing asynchronize statement for this object, and that this machine hascorrespondingly synchronized the object locally. In such a case, theoriginal code block is NOT to be executed until this machine canguarantee that no other machine is executing a synchronize statement forthis object, as it will potentially corrupt the object across theparticipating machines due to race-conditions, inconsistency of memory,and so forth resulting from the concurrent execution of synchronizedstatements. Thus, when the DRT determines that this object is presently“synchronized”, the DRT prevents execution of the original code-block bypausing the execution of the “acquireLock( )” operation until such atime as a corresponding “releaseLock( )” operation is executed by thepresent owner of the lock.

Thus, on execution of a “releaseLock( )” operation, the machine whichpresently “owns” a lock (ie, is executing a synchronized statement)indicates the close of its synchronized statement, for example bymarking this object as “unsynchronised” in the shared table ofsynchronization states, or alternatively, sequentially releasing locksacquired on all other machines. At this point, any other machine waitingto begin execution of a corresponding synchronized statement can thenclaim ownership of this object's lock by resuming execution of itspostponed (ie delayed) “acquireLock( )” operation, for example, markingitself as executing a synchronized statement for this object in theshared table of synchronization states, or alternatively, sequentiallyacquiring local locks on each of the other machines.

So, taking advantage of the DRT, the application code is modified as itis loaded into the machine by changing the synchronization routine(consisting of a beginning “monitorenter” and an ending “monitorexit”instruction/s). The changes made (highlighted in bold) are the initialinstructions that the synchronization routine executes. These addedinstructions check if this lock has already been acquired by anothermachine. If this lock has not been acquired by another machine, then theDRT of this machine notifies all other machines that this machine hasacquired the lock, and thereby stopping the other machines fromexecuting synchronization routines for this lock.

The DRT can record the lock status of the machines in many ways, forexample:

-   1. corresponding to the entry to a synchronization routine, the DRT    individually consults each machine to ascertain if this lock is    already acquired. If so, the DRT pauses the execution of the    synchronization routine until all other machines no longer own a    lock on this asset or object. Otherwise, the DRT executes this    synchronization routine. Alternatively,-   2. corresponding to the entry to a synchronization routine, the DRT    consults a shared table of records (for example a shared database,    or a copy of a shared table on each of the participating machines)    which indicate if any machine currently “owns” this lock. If so, the    DRT then pauses execution of the synchronization routine on this    machine until all other machines no longer own a lock on this    object. Otherwise the DRT records this machine in the shared table    (or tables, if there are multiple tables of records, eg, on multiple    machines) as the owner of this lock, and then executes the    synchronization routine.

Similarly, when a lock is released, that is to say, when the executionof a synchronization routine is to end, the DRT can “un-record” the lockstatus of machines in many alternative ways, for example:

-   1. corresponding to the exit to a synchronization routine, the DRT    individually notifies each other machine that it no longer owns the    lock. Alternatively,    -   2. corresponding to the exit to a synchronization routine, the        DRT updates the record for this locked asset or object in the        shared table(s) of records such that this machine is no longer        recorded as owning this lock.

Still further, the DRT can queue machines needing to acquire a lockedobject in multiple alternative ways, for example:

-   1. corresponding to the entry to a synchronization routine, the DRT    notifies the present owner of the locked object that a specific    machine would like to acquire the lock upon release by the current    owning machine. The specified machine, if there are no other waiting    machines, then stores a record of the specified machine's interest    in a table, which, following the exit of the synchronization routine    of the locked object, then notifies the waiting machine that it can    acquire this locked object, and thus begin executing its    synchronization routine,-   2. corresponding to the entry to a synchronization routine, the DRT    notifies the present owner of the locked object that a specific    machine (say machine M6) would like to acquire the lock upon release    by that machine (say machine M4). That machine M4, if it finds after    consulting its records of waiting machines for this locked object,    finds that there are already one or more machines waiting, then    either appends machine M6 to the end of the list of machines wanting    to acquire this locked object, or alternatively, forwards the    request from M6 to the first waiting, or any other machine waiting,    machine which then, in turn, records machine M6 in their table of    records,-   3. corresponding to the entry to a synchronization routine, the DRT    records itself in a shared table(s) of records (for example, a table    stored in a shared database accessible by all machines, or multiple    separate tables which are substantially similar).

Still further, the DRT can notify other machines queued to acquire thislock corresponding to the exit of a synchronization routine by thismachine in the following alternative ways, for example:

-   1. corresponding to the exit of a synchronization routine, the DRT    notifies one of the awaiting machines (for example, this first    machine in the queue of waiting machines) that the lock is released,-   2. corresponding to the exit of a synchronization routine, the DRT    notifies one of the awaiting machines (for example, the first    machine in the queue of waiting machines) that the lock is released,    and additionally, provides a copy of the entire queue of machines    (for example, the second machine and subsequent machines awaiting    for this lock). This way, the second machine inherits the list of    waiting machines from the first machine, and thereby ensures the    continuity of the queue of waiting machines as each machine in turn    down the list acquires and subsequently releases the lock.

During the abovementioned scrutiny, “monitorenter” and “monitorexit”instructions (or methods) are initially looked for and, when found, amodifying code is inserted so as to give rise to a modifiedsynchronization routine. This modified routine acquires and releases alock. There are several different modes whereby this modification andloading can be carried out.

As seen in FIG. 15 a modification to the general arrangement of FIG. 8is provided in that machines M1, M2 . . . Mn are as before and run thesame application program 50 (or programmes) on all machinessimultaneously. However, the previous arrangement is modified by theprovision of a server machine X which is conveniently able to supplyhousekeeping functions, for example, and especially the synchronizationof structures, assets and resources. Such a server machine X can be alow value commodity computer such as a PC since its computational loadis low. As indicated by broken lines in FIG. 15, two server machines Xand X+1 can be provided for redundancy purposes to increase the overallreliability of the system. Where two such server machines X and X+1 areprovided, they are preferably operated as dual machines in a cluster.

It is not necessary to provide a server machine X as its computationalload can be distributed over machines M1, M2 . . . Mn. Alternatively, adatabase operated by one machine (in a master/slave type operation) canbe used for the housekeeping function(s).

FIG. 16 shows a preferred general procedure to be followed. Afterloading 161 has been commenced, the instructions to be executed areconsidered in sequence and all synchronization routines are detected asindicated in step 162. In the JAVA language these are the “monitorenter”and “monitorexit” instructions. Other languages use different terms.

Where a synchronization routine is detected, it is modified, typicallyby inserting further instructions into the routine. Alternatively, themodifying instructions could be inserted prior to the routine. Once themodification has been completed the loading procedure continues. Themodifications preferably take the form of an “acquire lock on all othermachines” operation and a “release lock on all other machines”modification as indicated at step 163.

FIG. 17 illustrates a particular form of modification. Firstly, thestructures, assets or resources (in JAVA termed classes or objects eg50A, 50X-50Y) to be synchronized have already been allocated a name ortag which can be used globally by all machines, as indicated by step172. This preferably happens when the classes or objects are originallyinitialized. This is most conveniently done via a table maintained byserver machine X. This table also includes the synchronization status ofthe class or object. In the preferred embodiment, this table alsoincludes a queue arrangement which stores the identities of machineswhich have requested use of this asset.

As indicated in step 173 of FIG. 17, next an “acquire lock” request issent to machine X, after which, the sending machine awaits forconfirmation of lock acquisition as shown in step 174. Thus, if theglobal name is already locked (ie the corresponding asset is in use byanother machine other than the machine proposing to acquire the lock)then this means that the proposed synchronization routine of the objector class should be paused until the object or class is unlocked by thecurrent owner.

Alternatively, if the global name is not locked, this means that noother machine is using this class or object, and confirmation of lockacquisition is received straight away. After receipt of confirmation oflock acquisition, execution of the synchronization routine is allowed tocontinue, as shown in step 175

FIG. 18 shows the procedures followed by the application programexecuting machine which wishes to relinquish a lock. The initial step isindicated at step 181. The operation of this proposing machine istemporarily interrupted by steps 183, 184 until the reply is receivedfrom machine X, corresponding to step 184, and execution then resumes asindicated in step 185. Optionally, and as indicated in step 182, themachine requesting release of a lock is made to lookup the “global name”for this lock preceding a request being made to machine X. This way,multiple locks on multiple machines can be acquired and released withoutinterfering with one another.

FIG. 19 shows the activity carried out by machine X in response to an“acquire lock” enquiry (of FIG. 17). After receiving an “acquire lock”request at step 191, the lock status is determined at steps 192 and 193and, if no—the named resource is not free, the identity of the enquiringmachine is added at step 194 to (or forms) the queue of awaitingacquisition requests. Alternatively, if the answer is yes—the namedresource is free—the corresponding reply is sent at step 197. Thewaiting enquiring machine is then able to execute the synchronizationroutine accordingly by carrying out step 175 of FIG. 17. In addition tothe yes response, the shared table is updated at step 196 so that thestatus of the globally named asset is changed to “locked”.

FIG. 20 shows the activity carried out by machine X in response to a“release lock” request of FIG. 18. After receiving a “release lock”request at step 201, machine X optionally, and preferably, confirms thatthe machine requesting to release the lock is indeed the current ownerof the lock”, as indicated in step 202. Next, the queue status isdetermined at step 203 and, if no-one is waiting to acquire this lock,machine X marks this lock as “unowned” in the shared table, as shown instep 207, and optionally sends a confirmation of release back to therequesting machine, as indicated by step 208. This enables therequesting machine to execute step 185 of FIG. 18.

Alternatively, if yes—that is, other machines are waiting to acquirethis lock—machine X marks this lock as now acquired by the next machinein the queue, as shown in step 204, and then sends a confirmation oflock acquisition to the queued machine at step 205, and consequentlyremoves the new lock owner from the queue of waiting machines, asindicated in step 206.

Given the fundamental concept of modifying the synchronization routinesthere are several different ways in which this concept can beimplemented.

In the first embodiment, a particular machine, say machine M2, loads thesynchronization routine on itself, modifies it, and then loads each ofthe other machines M1, M3 . . . Mn (either sequentially orsimultaneously) with the modified synchronization routine. In thisarrangement, which may be termed “master/slave” each of machines M1, M3,. . . Mn loads what it is given by machine M2.

In a variation of this “master/slave” arrangement, machine M2 loads thesynchronization routine in unmodified form on machine M2 and then on theother machines deletes the synchronization routine in its entirety andloads the modified code. Thus in this instance the modification is not aby-passing of the synchronization routine but a deletion of it on allmachines except one.

In a still further embodiment, each machine receives the synchronizationroutine, but modifies it and loads the modified routine on that machine.This enables the modification carried out by each machine to be slightlydifferent being optimized based upon its architecture and operatingsystem, yet still coherent with all other similar modifications.

In a further arrangement, a particular machine, say M1, loads theunmodified synchronization routine and all other machines M2, M3 . . .Mn do a modification to delete the original synchronization routine andload the modified version.

In all instances, the supply can be branched (ie M2 supplies each of M1,M3, M4, etc directly) or cascaded or sequential (ie M2 applies M1 whichthen supplies M3 which then supplies M4, and so on).

In a still further arrangement, the machines M1 to Mn, can send all loadrequests to an additional machine X (of FIG. 15), which performs themodification via any of the afore mentioned methods, and returns themodified routine to each of the machines M1 to Mn which then load themodified routine locally. In this arrangement, machines M1 to Mn forwardall load requests to machine X, which returns a modified routine to eachmachine. The modifications performed by machine X can include any of themodifications covered under the scope of the present invention.

Persons skilled in the computing arts will be aware of four techniquesused in creating modifications in computer code. The first is to makethe modification in the original (source) language. The second is toconvert the original code (in say JAVA) into an intermediaterepresentation (or intermediate language). Once this conversion takesplace the modification is made and then the conversion is reversed. Thisgives the desired result of modified JAVA code.

The third possibility is to convert to machine code (either directly orvia the abovementioned intermediate language). Then the machine code ismodified before being loaded and executed. The fourth possibility is toconvert the original code to an intermediate representation, which isthen modified and subsequently converted into machine code.

The present invention encompasses all four modification routes and alsoa combination of two, three or even all four, of such routes.

Turning now to FIGS. 21-23, two laptop computers 101 and 102 areillustrated. The computers 101 and 102 are not necessarily identical andindeed, one can be an IBM or IBM-clone and the other can be an APPLEcomputer. The computers 101 and 102 have two screens 105, 115 twokeyboards 106, 116 but a single mouse 107. The two machines 101, 102 areinterconnected by a means of a single coaxial cable or twisted paircable 314.

Two simple application programs are downloaded onto each of the machines101, 102, the programs being modified as they are being loaded asdescribed above. In this embodiment the first application is a simplecalculator program and results in the image of a calculator 108 beingdisplayed on the screen 105. The second program is a graphics programwhich displays four coloured blocks 109 which are of different coloursand which move about at random within a rectangular box 310. Again,after loading, the box 310 is displayed on the screen 105. Eachapplication operates independently so that the blocks 109 are in randommotion on the screen 105 whilst numerals within the calculator 108 canbe selected (with the mouse 107) together with a mathematical operator(such as addition or multiplication) so that the calculator 108 displaysthe result.

The mouse 107 can be used to “grab” the box 310 and move same to theright across the screen 105 and onto the screen 115 so as to arrive atthe situation illustrated in FIG. 22. In this arrangement, thecalculator application is being conducted on machine 101 whilst thegraphics application resulting in display of box 310 is being conductedon machine 102.

However, as illustrated in FIG. 23, it is possible by means of the mouse107 to drag the calculator 108 to the right as seen in FIG. 22 so as tohave a part of the calculator 108 displayed by each of the screens 105,115. Similarly, the box 310 can be dragged by means of the mouse 107 tothe left as seen in FIG. 22 so that the box 310 is partially displayedby each of the screens 105, 115 as indicated FIG. 23. In thisconfiguration, part of the calculator operation is being performed onmachine 101 and part on machine 102 whilst part of the graphicsapplication is being carried out the machine 101 and the remainder iscarried out on machine 102.

The foregoing describes only some embodiments of the present inventionand modifications, obvious to those skilled in the art, can be madethereto without departing from the scope of the present invention. Forexample, reference to JAVA includes both the JAVA language and also JAVAplatform and architecture.

Those skilled in the programming arts will be aware that when additionalcode or instructions is/are inserted into an existing code orinstruction set to modify same, the existing code or instruction set maywell require further modification (eg by re-numbering of sequentialinstructions) so that offsets, branching, attributes, mark up and thelike are catered for.

Similarly, in the JAVA language memory locations include, for example,both fields and array types. The above description deals with fields andthe changes required for array types are essentially the same mutatismutandis. Also the present invention is equally applicable to similarprogramming languages (including procedural, declarative and objectorientated) to JAVA including Micrsoft.NET platform and architecture(Visual Basic, Visual C/C⁺⁺, and C#) FORTRAN, C/C⁺⁺, COBOL, BASIC etc.

The abovementioned embodiment in which the code of the JAVAsynchronization routine is modified, is based upon the assumption thateither the run time system (say, JAVA HOTSPOT VIRTUAL MACHINE written inC and JAVA) or the operating system (LINUX written in C and Assembler,for example) of each machine M1 . . . Mn will normally acquire the lockon the local machine (say M2) but not on any other machines (M1, M3 . .. Mn). It is possible to leave the JAVA synchronization routineunamended and instead amend the LINUX or HOTSPOT routine which acquiresthe lock locally, so that it correspondingly acquires the lock on allother machines as well. In order to embrace such an arrangement the term“synchronization routine” is to be understood to include within itsscope both the JAVA synchronization routine and the “combination” of theJAVA synchronization routine and the LINUX or HOTSPOT code fragmentswhich perform lock acquisition and release.

The terms object and class used herein are derived from the JAVAenvironment and are intended to embrace similar terms derived fromdifferent environments such as dynamically linked libraries (DLL), orobject code packages, or function unit or memory locations.

The term “comprising” (and its grammatical variations) as used herein isused in the inclusive sense of “having” or “including” and not in theexclusive sense of “consisting only of”.

Copyright Notice

This patent specification contains material which is subject tocopyright protection. The copyright owner (which is the applicant) hasno objection to the reproduction of this patent specification or relatedmaterials from publicly available associated Patent Office files for thepurposes of review, but otherwise reserves all copyright whatsoever. Inparticular, the various instructions are not to be entered into acomputer without the specific written approval of the copyright owner.

Annexure A

The following are program listings in the JAVA language:

A1. This first excerpt is part of the modification code. It searchesthrough the code array, and when it finds a putstatic instruction(opcode 178), it implements the modifications. // START byte[ ] code =Code_attribute.code; // Bytecode of a given method in a // givenclassfile. int code_length = Code_attribute.code_length; int DRT = 99;// Location of the CONSTANT_Methodref_info for the // DRT.alert( )method. for (int i=0; i<code_length; i++){  if ((code[i] & 0xff) ==179){ // Putstatic instruction.   System.arraycopy(code, i+3, code, i+6,code_length−(i+3));   code[i+3] = (byte) 184; // Invokestaticinstruction for the // DRT.alert( ) method.   code[i+4] = (byte)((DRT >>> 8) & 0xff);   code[i+5] = (byte) (DRT & 0xff);  } } // END

A2. This second excerpt is part of the DRT.alert( ) method. This is thebody of the DRT.alert( ) method when it is called. // START publicstatic void alert( ){  synchronized (ALERT_LOCK){   ALERT_LOCK.notify(); // Alerts a waiting DRT thread   in the background.  } } // END

A3. This third excerpt is part of the DRT Sending. This code fragmentshows the DRT in a separate thread, after being notified, sending thevalue across the network. // START MulticastSocket ms =DRT.getMulticastSocket( ); // The multicast socket // used by the DRTfor // communication. byte nameTag = 33; // This is the “name tag” onthe network for this // field. Field field =modifiedClass.getDeclaredField(“myField1”); // Stores // the field //from the // modified // class. // In this example, the field is a bytefield. while (DRT.isRunning( )){  synchronized (ALERT_LOCK){  ALERT_LOCK.wait( ); // The DRT thread is waiting for the alert //method to be called.   byte[ ] b = new byte[ ]{nameTag,field.getByte(null)}; // Stores // the // nameTag // and the // value //of the // field from // the // modified // class in a buffer.  DatagramPacket dp = new DatagramPacket(b, 0, b.length);  ms.send(dp); // Send the buffer out across the network.  } } // END

A4. The fourth excerpt is part of the DRT receiving. This is a fragmentof code to receive a DRT sent alert over the network. // STARTMulticastSocket ms = DRT.getMulticastSocket( ); // The multicast socket// used by the DRT for // communication. DatagramPacket dp = newDatagramPacket(new byte[2], 0, 2); byte nameTag = 33; // This is the“name tag” on the network for this // field. Field field =modifiedClass.getDeclaredField(“myField1”); // Stores the // field from// the // modified class. // In this example, the field is a byte field.while (DRT.isRunning){  ms.receive(dp); // Receive the previously sentbuffer from the  network.  byte[ ] b = dp.getData( );  if (b[0] ==nameTag){ // Check the nametags match.   field.setByte(null, b[1]); //Write the value from the network packet // into the field location inmemory.  } } // END

A5. The fifth excerpt is an example application before modification hasoccurred. Method void setValues(int, int)  0 iload_1  1 putstatic #3<Field int staticValue>  4 aload_0  5 iload_2  6 putfield #2 <Field intinstanceValue>  9 return

A6. The sixth excerpt is the same example application in 5 aftermodification has been performed. The modifications are highlighted inbold. Method void setValues(int, int)   0 iload_1   1 putstatic #3<Field int staticValue>   4 ldc #4 <String “example”>   6 iconst_0   7invokestatic #5 <Method void alert(java.lang.Object, int)>  10 aload_0 11 iload_2  12 putfield #2 <Field int instanceValue>  15 aload_0  16iconst_1  17 invokestatic #5 <Method void alert(java.lang.Object, int)> 20 return

A7. The seventh excerpt is the source-code of the example applicationused in excerpt 5 and 6. import java.lang.*; public class example{  /**Shared static field. */  public static int staticValue = 0;  /** Sharedinstance field. */  public int instanceValue = 0;  /** Example methodthat writes to memory (instance field). */  public void setValues(int a,int b){   staticValue = a;   instanceValue = b;  } }

A8. The eighth excerpt is the source-code of FieldAlert, which alertsthe “distributed run-time” to propagate a changed value. importjava.lang.*; import java.util.*; import java.net.*; import java.io.*;public class FieldAlert{  /** Table of alerts. */  public final staticHashtable alerts = new Hashtable( );  /** Object handle. */  publicObject reference = null;  /** Table of field alerts for this object. */ public boolean[ ] fieldAlerts = null;  /** Constructor. */  publicFieldAlert(Object o, int initialFieldCount){   reference = o;  fieldAlerts = new boolean[initialFieldCount];  }  /** Called when anapplication modifies a value. (Both objects and   classes) */  publicstatic void alert(Object o, int fieldID){   // Lock the alerts table.  synchronized (alerts){    FieldAlert alert = (FieldAlert)alerts.get(o);    if (alert == null){ // This object hasn't been alertedalready, // so add to alerts table.     alert = new FieldAlert(o,fieldID + 1);     alerts.put(o, alert);    }    if (fieldID >=alert.fieldAlerts.length){     // Ok, enlarge fieldAlerts array.    boolean[ ] b = new boolean[fieldID+1];    System.arraycopy(alert.fieldAlerts, 0, b, 0,     alert.fieldAlerts.length);     alert.fieldAlerts = b;    }    //Record the alert.    alert.fieldAlerts[fieldID] = true;    // Mark aspending.    FieldSend.pending = true; // Signal that there is one ormore // propagations waiting.    // Finally, notify the waitingFieldSend thread(s)    if (FieldSend.waiting){     FieldSend.waiting =false;     alerts.notify( );    }   }  } }

A9. The ninth excerpt is the source-code of FieldSend, which propagateschanges values alerted to it via FieldAlert. import java.lang.*; importjava.lang.reflect.*; import java.util.*; import java.net.*; importjava.io.*; public class FieldSend implements Runnable{  /** Protocolspecific values. */  public final static int CLOSE = −1;  public finalstatic int NACK = 0;  public final static int ACK = 1;  public finalstatic int PROPAGATE_OBJECT = 10;  public final static intPROPAGATE_CLASS = 20;  /** FieldAlert network values. */  public finalstatic String group =   System.getProperty(“FieldAlert_network_group”); public final static int port =  Integer.parseInt(System.getProperty(“FieldAlert_network_port”));  /**Table of global ID's for local objects. (hashcode-to-globalID  mappings) */  public final static Hashtable objectToGlobalID = newHashtable( );  /** Table of global ID's for local classnames.(classname-to-globalID   mappings) */  public final static HashtableclassNameToGlobalID = new Hashtable( );  /** Pending. True if apropagation is pending. */  public static boolean pending = false;  /**Waiting. True if the FieldSend thread(s) are waiting. */  public staticboolean waiting = false;  /** Background send thread. Propagates valuesas this thread is alerted   to their alteration. */  public void run( ){  System.out.println(“FieldAlert_network_group=” + group);  System.out.println(“FieldAlert_network_port=” + port);   try{    //Create a DatagramSocket to send propagated field values.   DatagramSocket datagramSocket =     new DatagramSocket(port,InetAddress.getByName(group));    // Next, create the buffer and packetfor all transmissions.    byte[ ] buffer = new byte[512]; // Workinglimit of 512 bytes // per packet.    DatagramPacket datagramPacket =    new DatagramPacket(buffer, 0, buffer.length);    while(!Thread.interrupted( )){     Object[ ] entries = null;     // Lock thealerts table.     synchronized (FieldAlert.alerts){      // Await for analert to propagate something.      while (!pending){       waiting =true;       FieldAlert.alerts.wait( );       waiting = false;      }     pending = false;      entries = FieldAlert.alerts.entrySet().toArray( );      // Clear alerts once we have copied them.     FieldAlert.alerts.clear( );     }     // Process each object alertin turn.     for (int i=0; i<entries.length; i++){      FieldAlert alert= (FieldAlert) entries[i];      int index = 0;     datagramPacket.setLength(buffer.length);      Object reference =null;      if (alert.reference instanceof String){       //PROPAGATE_CLASS field operation.       buffer[index++] = (byte)      ((PROPAGATE_CLASS >> 24) & 0xff);       buffer[index++] = (byte)      ((PROPAGATE_CLASS >> 16) & 0xff);       buffer[index++] = (byte)      ((PROPAGATE_CLASS >> 8) & 0xff);       buffer[index++] = (byte)      ((PROPAGATE_CLASS >> 0) & 0xff);       String name = (String)alert.reference;       int length = name.length( );      buffer[index++] = (byte) ((length >> 24) & 0xff);      buffer[index++] = (byte) ((length >> 16) & 0xff);      buffer[index++] = (byte) ((length >> 8) & 0xff);      buffer[index++] = (byte) ((length >> 0) & 0xff);       byte[ ]bytes = name.getBytes( );       System.arraycopy(bytes, 0, buffer,index, length);       index += length;      }else{       //PROPAGATE_OBJECT field operation.       buffer[index++] =        (byte)((PROPAGATE_OBJECT >> 24) & 0xff);       buffer[index++] =        (byte)((PROPAGATE_OBJECT >> 16) & 0xff);       buffer[index++] = (byte)      ((PROPAGATE_OBJECT >> 8) & 0xff);       buffer[index++] = (byte)      ((PROPAGATE_OBJECT >> 0) & 0xff);       int globalID = ((Integer)       objectToGlobalID.get(alert.reference)).intValue( );      buffer[index++] = (byte) ((globalID >> 24) & 0xff);      buffer[index++] = (byte) ((globalID >> 16) & 0xff);      buffer[index++] = (byte) ((globalID >> 8) & 0xff);      buffer[index++] = (byte) ((globalID >> 0) & 0xff);       reference= alert.reference;      }      // Use reflection to get a table offields that correspond to      // the field indexes used internally.     Field[ ] fields = null;      if (reference == null){       fields =FieldLoader.loadClass((String)       alert.reference).getDeclaredFields( );      }else{       fields =alert.reference.getClass( ).getDeclaredFields( );      }      // Nowencode in batch mode the fieldID/value pairs.      for (int j=0;j<alert.fieldAlerts.length; j++){       if (alert.fieldAlerts[j] ==false)        continue;       buffer[index++] = (byte) ((j >> 24) &0xff);       buffer[index++] = (byte) ((j >> 16) & 0xff);      buffer[index++] = (byte) ((j >> 8) & 0xff);       buffer[index++]= (byte) ((j >> 0) & 0xff);       // Encode value.       Class type =fields[j].getType( );       if (type == Boolean.TYPE){       buffer[index++] =(byte)         (fields[j].getBoolean(reference)?1 : 0);       }else if (type == Byte.TYPE){        buffer[index++] =fields[j].getByte(reference);       }else if (type == Short.TYPE){       short v = fields[j].getShort(reference);        buffer[index++] =(byte) ((v >> 8) & 0xff);        buffer[index++] = (byte) ((v >> 0) &0xff);       }else if (type == Character.TYPE){        char v =fields[j].getChar(reference);        buffer[index++] = (byte) ((v >> 8)& 0xff);        buffer[index++] = (byte) ((v >> 0) & 0xff);       }elseif (type == Integer.TYPE){        int v = fields[j].getInt(reference);       buffer[index++] = (byte) ((v >> 24) & 0xff);       buffer[index++] = (byte) ((v >> 16) & 0xff);       buffer[index++] = (byte) ((v >> 8) & 0xff);       buffer[index++] = (byte) ((v >> 0) & 0xff);       }else if (type== Float.TYPE){        int v = Float.floatToIntBits(        fields[j].getFloat (reference));        buffer[index++] = (byte)((v >> 24) & 0xff);        buffer[index++] = (byte) ((v >> 16) & 0xff);       buffer[index++] = (byte) ((v >> 8) & 0xff);       buffer[index++] = (byte) ((v >> 0) & 0xff);       }else if (type== Long.TYPE){        long v = fields[j].getLong(reference);       buffer[index++] = (byte) ((v >> 56) & 0xff);       buffer[index++] = (byte) ((v >> 48) & 0xff);       buffer[index++] = (byte) ((v >> 40) & 0xff);       buffer[index++] = (byte) ((v >> 32) & 0xff);       buffer[index++] = (byte) ((v >> 24) & 0xff);       buffer[index++] = (byte) ((v >> 16) & 0xff);       buffer[index++] = (byte) ((v >> 8) & 0xff);       buffer[index++] = (byte) ((v >> 0) & 0xff);       }else if (type== Double.TYPE){        long v = Double.doubleToLongBits(        fields[j].getDouble(reference));        buffer[index++] = (byte)((v >> 56) & 0xff);        buffer[index++] = (byte) ((v >> 48) & 0xff);       buffer[index++] = (byte) ((v >> 40) & 0xff);       buffer[index++] = (byte) ((v >> 32) & 0xff);       buffer[index++] = (byte) ((v >> 24) & 0xff);       buffer[index++] = (byte) ((v >> 16) & 0xff);       buffer[index++] = (byte) ((v >> 8) & 0xff);       buffer[index++] = (byte) ((v >> 0) & 0xff);       }else{       throw new AssertionError(“Unsupported type.”);       }      }     // Now set the length of the datagrampacket.     datagramPacket.setLength(index);      // Now send the packet.     datagramSocket.send(datagramPacket);     }    }   }catch (Exceptione){    throw new AssertionError(“Exception: ” + e.toString( ));   }  } }

A10. The tenth excerpt is the source-code of FieldReceive, whichreceives propagated changed values sent via FieldSend. importjava.lang.*; import java.lang.reflect.*; import java.util.*; importjava.net.*; import java.io.*; public class FieldReceive implementsRunnable{  /** Protocol specific values. */  public final static intCLOSE = −1;  public final static int NACK = 0;  public final static intACK = 1;  public final static int PROPAGATE_OBJECT = 10;  public finalstatic int PROPAGATE_CLASS = 20;  /** FieldAlert network values. */ public final static String group =  System.getProperty(“FieldAlert_network_group”);  public final staticint port =  Integer.parseInt(System.getProperty(“FieldAlert_network_port”));  /**Table of global ID's for local objects. (globalID-to-hashcode  mappings) */  public final static Hashtable globalIDToObject = newHashtable( );  /** Table of global ID's for local classnames.(globalID-to-classname   mappings) */  public final static HashtableglobalIDToClassName = new Hashtable( );  /** Called when an applicationis to acquire a lock. */  public void run( ){  System.out.println(“FieldAlert_network_group=” + group);  System.out.println(“FieldAlert_network_port=” + port);   try{    //Create a DatagramSocket to send propagated field values from   MulticastSocket multicastSocket = new MulticastSocket(port);   multicastSocket.joinGroup(InetAddress.getByName(group));    // Next,create the buffer and packet for all transmissions.    byte[ ] buffer =new byte[512]; // Working limit of 512 // bytes per packet.   DatagramPacket datagramPacket =     new DatagramPacket(buffer, 0,buffer.length);    while (!Thread.interrupted( )){     // Make sure toreset length.     datagramPacket.setLength(buffer.length);     //Receive the next available packet.    multicastSocket.receive(datagramPacket);     int index = 0, length =datagramPacket.getLength( );     // Decode the command.     int command= (int) (((buffer[index++] & 0xff) << 24)      | ((buffer[index++] &0xff) << 16)      | ((buffer[index++] & 0xff) << 8)      |(buffer[index++] & 0xff));     if (command == PROPAGATE_OBJECT){ //Propagate // operation for object fields.      // Decode global id.     int globalID = (int) (((buffer[index++] & 0xff) << 24)       |((buffer[index++] & 0xff) << 16)       | ((buffer[index++] & 0xff) << 8)      | (buffer[index++] & 0xff));      // Now, need to resolve theobject in question.      Object reference = globalIDToObject.get(      new Integer (globalID));      // Next, get the array of fields forthis object.      Field[ ] fields = reference.getClass().getDeclaredFields( );      while (index < length){       // Decode thefield id.       int fieldID = (int) (((buffer[index++] & 0xff) << 24)       | ((buffer[index++] & 0xff) << 16)        | ((buffer[index++] &0xff) << 8)        | (buffer[index++] & 0xff));       // Determine valuelength based on corresponding field       // type.       Field field =fields[fieldID];       Class type = field.getType( );       if (type ==Boolean.TYPE){        boolean v = (buffer[index++] == 1 ? true : false);       field.setBoolean(reference, v);       }else if (type ==Byte.TYPE){        byte v = buffer[index++];       field.setByte(reference, v);       }else if (type == Short.TYPE){       short v = (short) (((buffer[index++] & 0xff) << 8)         |(buffer[index++] & 0xff));        field.setShort(reference, v);      }else if (type == Character.TYPE){        char v = (char)(((buffer[index++] & 0xff) << 8)         | (buffer[index++] & 0xff));       field.setChar(reference, v);       }else if (type ==Integer.TYPE){        int v = (int) (((buffer[index++] & 0xff) << 24)        | ((buffer[index++] & 0xff) << 16)         | ((buffer[index++] &0xff) << 8)         | (buffer[index++] & 0xff));       field.setInt(reference, v);       }else if (type == Float.TYPE){       int v = (int) (((buffer[index++] & 0xff) << 24)         |((buffer[index++] & 0xff) << 16)         | ((buffer[index++] & 0xff) <<8)         | (buffer[index++] & 0xff));        field.setFloat(reference,Float.intBitsToFloat(v));       }else if (type == Long.TYPE){       long v = (long) (((buffer[index++] & 0xff) << 56)         |((buffer[index++] & 0xff) << 48)         | ((buffer[index++] & 0xff) <<40)         | ((buffer[index++] & 0xff) << 32)         |((buffer[index++] & 0xff) << 24)         | ((buffer[index++] & 0xff) <<16)         | ((buffer[index++] & 0xff) << 8)         | (buffer[index++]& 0xff));        field.setLong(reference, v);       }else if (type ==Double.TYPE){        v = (long) (((buffer[index++] & 0xff) << 56)        | ((buffer[index++] & 0xff) << 48)         | ((buffer[index++] &0xff) << 40)         | ((buffer[index++] & 0xff) << 32)         |((buffer[index++] & 0xff) << 24)         | ((buffer[index++] & 0xff) <<16)         | ((buffer[index++] & 0xff) << 8)         | (buffer[index++]& 0xff));        field.setDouble(reference, Double.longBitsToDouble(v));      }else{        throw new AssertionError(“Unsupported type.”);      }      }     }else if (command == PROPAGATE_CLASS){ // Propagate// an update to class fields.      // Decode the classname.      intnameLength = (int) (((buffer[index++] & 0xff) << 24)       |((buffer[index++] & 0xff) << 16)       | ((buffer[index++] & 0xff) << 8)      | (buffer[index++] & 0xff));      String name = new String(buffer,index, nameLength);      index += nameLength;      // Next, get thearray of fields for this class.      Field[ ] fields =      FieldLoader.loadClass(name).getDeclaredFields( );      // Decodeall batched fields included in this propagation      // packet.     while (index < length){       // Decode the field id.       intfieldID = (int) (((buffer[index++] & 0xff) << 24)        |((buffer[index++] & 0xff) << 16)        | ((buffer[index++] & 0xff) <<8)        | (buffer[index++] & 0xff));       // Determine field type todetermine value length.       Field field = fields[fieldID];       Classtype = field.getType( );       if (type == Boolean.TYPE){        booleanv = (buffer[index++] == 1 ? true : false);        field.setBoolean(null,v);       }else if (type == Byte.TYPE){        byte v = buffer[index++];       field.setByte(null, v);       }else if (type == Short.TYPE){       short v = (short) (((buffer[index++] & 0xff) << 8)         |(buffer[index++] & 0xff));        field.setShort(null, v);       }elseif (type == Character.TYPE){        char v = (char) (((buffer[index++] &0xff) << 8)         | (buffer[index++] & 0xff));       field.setChar(null, v);       }else if (type == Integer.TYPE){       int v = (int) (((buffer[index++] & 0xff) << 24)         |((buffer[index++] & 0xff) << 16)         | ((buffer[index++] & 0xff) <<8)         | (buffer[index++] & 0xff));        field.setInt(null, v);      }else if (type == Float.TYPE){        int v = (int)(((buffer[index++] & 0xff) << 24)         | ((buffer[index++] & 0xff) <<16)         | ((buffer[index++] & 0xff) << 8)         | (buffer[index++]& 0xff));        field.setFloat(null, Float.intBitsToFloat(v));      }else if (type == Long.TYPE){        long v = (long)(((buffer[index++] & 0xff) << 56)         | ((buffer[index++] & 0xff) <<48)         | ((buffer[index++] & 0xff) << 40)         |((buffer[index++] & 0xff) << 32)         | ((buffer[index++] & 0xff) <<24)         | ((buffer[index++] & 0xff) << 16)         |((buffer[index++] & 0xff) << 8)         | (buffer[index++] & 0xff));       field.setLong(null, v);       }else if (type == Double.TYPE){       long v = (long) (((buffer[index++] & 0xff) << 56)         |((buffer[index++] & 0xff) << 48)         | ((buffer[index++] & 0xff) <<40)         | ((buffer[index++] & 0xff) << 32)         |((buffer[index++] & 0xff) << 24)         | ((buffer[index++] & 0xff) <<16)         | ((buffer[index++] & 0xff) << 8)         | (buffer[index++]& 0xff));        field.setDouble(null, Double.longBitsToDouble(v));      }else{    // Unsupported field type.        throw newAssertionError(“Unsupported type.”);       }      }     }    }   }catch(Exception e){    throw new AssertionError(“Exception: ” + e.toString());   }  } }

-   A11. FieldLoader.java

This excerpt is the source-code of FieldLoader, which modifies anapplication as it is being loaded. import java.lang.*; import java.io.*;import java.net.*; public class FieldLoader extends URLClassLoader{ public FieldLoader(URL[ ] urls){   super(urls);  }  protected ClassfindClass(String name)  throws ClassNotFoundException{  ClassFile cf =null;  try{   BufferedInputStream in =    newBufferedInputStream(findResource(    name.replace(‘.’,‘/’).concat(“.class”)).openStream( ));   cf = new ClassFile(in);  }catch(Exception e){throw new  ClassNotFoundException(e.toString( ));}  //Class-wide pointers to the ldc and alert index.  int ldcindex = −1;  intalertindex = −1;  for (int i=0; i<cf.methods_count; i++){   for (intj=0; j<cf.methods[i].attributes_count; j++){    if(!(cf.methods[i].attributes[j] instanceof Code_attribute))     continue;   Code_attribute ca = (Code_attribute) cf.methods[i].attributes[j];   boolean changed = false;    for (int z=0; z<ca.code.length; z++){    if ((ca.code[z][0] & 0xff) == 179){ // Opcode for a PUTSTATIC                   // instruction.      changed = true;      // The codebelow only supports fields in this class.      // Thus, first off, checkthat this field is local to this      // class.     CONSTANT_Fieldref_info fi =      (CONSTANT_Fieldref_info)      cf.constant_pool[(int) (((ca.code[z][1] & 0xff) << 8) |      (ca.code[z][2] & 0xff))];      CONSTANT_Class_info ci =(CONSTANT_Class_info)       cf.constant_pool[fi.class_index];     String className =       cf.constant_pool[ci.name_index].toString();      if (!name.equals(className)){       throw newAssertionError(“This code only supports fields “        “local to thisclass”);      }      // Ok, now search for the fields name and index.     int index = 0;      CONSTANT_NameAndType_info ni =     (CONSTANT_NameAndType_info)      cf.constant_pool[fi.name_and_type_index];      String fieldName =      cf.constant_pool[ni.name_index].toString( );      for (int a=0;a<cf.fields_count; a++){       String fn = cf.constant_pool[       cf.fields[a].name_index].toString( );       if(fieldName.equals(fn)){        index = a;        break;       }      }     // Next, realign the code array, making room for the      //insertions.      byte[ ][ ] code2 = new byte[ca.code.length+3][ ];     System.arraycopy(ca.code, 0, code2, 0, z+1);     System.arraycopy(ca.code, z+1, code2, z+4,      ca.code.length−(z+1));      ca.code = code2;      // Next, insertthe LDC_W instruction.      if (ldcindex == −1){      CONSTANT_String_info csi =        newCONSTANT_String_info(ci.name_index);       cp_info[ ] cpi = newcp_info[cf.constant_pool.length+1];       System.arraycopy(cf.constant_pool, 0, cpi, 0,        cf.constant_pool.length);      cpi[cpi.length − 1] = csi;       ldcindex = cpi.length−1;      cf.constant_pool = cpi;       cf.constant_pool_count++;      }     ca.code[z+1] = new byte[3];      ca.code[z+1][0] = (byte) 19;     ca.code[z+1][1] = (byte) ((ldcindex >> 8) & 0xff);     ca.code[z+1][2] = (byte) (ldcindex & 0xff);      // Next, insertthe SIPUSH instruction.      ca.code[z+2] = new byte[3];     ca.code[z+2][0] = (byte) 17;      ca.code[z+2][1] = (byte)((index >> 8) & 0xff);      ca.code[z+2][2] = (byte) (index & 0xff);     // Finally, insert the INVOKESTATIC instruction.      if(alertindex == −1){       // This is the first time this class isencourtering the       // alert instruction, so have to add it to theconstant       // pool.       cp_info[ ] cpi = newcp_info[cf.constant_pool.length+6];      System.arraycopy(cf.constant_pool, 0, cpi, 0,       cf.constant_pool.length);       cf.constant_pool = cpi;      cf.constant_pool_count += 6;       CONSTANT_Utf8_info u1 =       new CONSTANT_Utf8_info(“FieldAlert”);      cf.constant_pool[cf.constant_pool.length−6] = u1;      CONSTANT_Class_info c1 = new       CONSTANT_Class_info(       cf.constant_pool_count−6);      cf.constant_pool[cf.constant_pool.length−5] = c1;       u1 = newCONSTANT_Utf8_info(“alert”);      cf.constant_pool[cf.constant_pool.length−4] = u1;       u1 = new      CONSTANT_Utf8_info(“(Ljava/lang/Object;I)V”);      cf.constant_pool[cf.constant_pool.length−3] = u1;      CONSTANT_NameAndType info n1 =        newCONSTANT_NameAndType_info(        cf.constant_pool.length−4,cf.constant_pool.length− 3);      cf.constant_pool[cf.constant_pool.length−2] = n1;      CONSTANT_Methodref_info m1 = new CONSTANT_Methodref_info(       cf.constant_pool.length−5, cf.constant_pool.length− 2);      cf.constant_pool[cf.constant_pool.length−1] = m1;       alertindex = cf.constant_pool.length−1;       }      ca.code[z+3] = new byte[3];       ca.code[z+3][0] = (byte) 184;      ca.code[z+3][1] = (byte) ((alertindex >> 8) & 0xff);      ca.code[z+3][2] = (byte) (alertindex & 0xff);       // And lastly,increase the CODE_LENGTH and ATTRIBUTE_LENGTH       // values.      ca.code_length += 9;       ca.attribute_length += 9;      }     }    // If we changed this method, then increase the stack size by one.    if (changed){      ca.max_stack++;    // Just to make sure.     }   }   }   try{    ByteArrayOutputStream out = newByteArrayOutputStream( );    cf.serialize(out);    byte[ ] b =out.toByteArray( );    return defineClass(name, b, 0, b.length);  }catch (Exception e){    throw new ClassNotFoundException(name);   } } }

-   A12. Attribute_info.java

Convience class for representing attribute_info structures withinClassFiles. import java.lang.*; import java.io.*; /** This abstractclass represents all types of attribute_info  *  that are used in theJVM specifications.  *  *  All new attribute_info subclasses are toalways inherit from this  *  class.  */ public abstract classattribute_info{  public int attribute_name_index;  public intattribute_length;  /** This is used by subclasses to register themselves  *  to their parent classFile.   */  attribute_info(ClassFile cf){ } /** Used during input serialization by ClassFile only. */ attribute_info(ClassFile cf, DataInputStream in)   throws IOException{  attribute_name_index = in.readChar( );   attribute_length =in.readInt( );  }  /** Used during output serialization by ClassFileonly. */  void serialize(DataOutputStream out)   throws IOException{  out.writeChar(attribute_name_index);   out.writeInt(attribute_length); }  /** This class represents an unknown attribute_info that   *  thiscurrent version of classfile specification does   *  not understand.  */  public final static class Unknown extends attribute_info{   byte[] info;   /** Used during input serialization by ClassFile only. */  Unknown(ClassFile cf, DataInputStream in)    throws IOException{   super(cf, in);    info = new byte[attribute_length];    in.read(info,0, attribute_length);   }   /** Used during output serialization byClassFile only. */   void serialize(DataOutputStream out)    throwsIOException{    ByteArrayOutputStream baos = new ByteArrayOutputStream();    super.serialize(out);    out.write(info, 0, attribute_length);   } } }

-   A13. ClassFile.java

Convience class for representing ClassFile structures. importjava.lang.*; import java.io.*; import java.util.*; /** The ClassFilefollows verbatim from the JVM specification. */ public final classClassFile {  public int magic;  public int minor_version;  public intmajor_version;  public int constant_pool_count;  public cp_info[ ]constant_pool;  public int access_flags;  public int this_class;  publicint super_class;  public int interfaces_count;  public int[ ]interfaces;  public int fields_count;  public field_info[ ] fields; public int methods_count;  public method_info[ ] methods;  public intattributes_count;  public attribute_info[ ] attributes;  /**Constructor. Takes in a byte stream representation and transforms   * each of the attributes in the ClassFile into objects to allow for   * easier manipulation.   */  public ClassFile(InputStream ins)   throwsIOException{   DataInputStream in = (ins instanceof DataInputStream ?   (DataInputStream) ins : new DataInputStream(ins));   magic =in.readInt( );   minor_version = in.readChar( );   major_version =in.readChar( );   constant_pool_count = in.readChar( );   constant_pool= new cp_info[constant_pool_count];   for (int i=1;i<constant_pool_count; i++){    in.mark(1);    int s = in.read( );   in.reset( );    switch (s){     case 1:      constant_pool[i] = newCONSTANT_Utf8_info(this, in);      break;     case 3:     constant_pool[i] = new CONSTANT_Integer_info(this, in);      break;    case 4:      constant_pool[i] = new CONSTANT_Float_info(this, in);     break;     case 5:      constant_pool[i] = newCONSTANT_Long_info(this, in);      i++;      break;     case 6:     constant_pool[i] = new CONSTANT_Double_info(this, in);      i++;     break;     case 7:      constant_pool[i] = newCONSTANT_Class_info(this, in);      break;     case 8:     constant_pool[i] = new CONSTANT_String_info(this, in);      break;    case 9:      constant_pool[i] = new CONSTANT_Fieldref_info(this,in);      break;     case 10:      constant_pool[i] = newCONSTANT_Methodref_info(this, in);      break;     case 11:     constant_pool[i] =       new CONSTANT_InterfaceMethodref_info(this,in);      break;     case 12:      constant_pool[i] = newCONSTANT_NameAndType_info(this, in);      break;     default:      thrownew ClassFormatError(“Invalid ConstantPoolTag”);    }   }   access_flags= in.readChar( );   this_class = in.readChar( );   super_class =in.readChar( );   interfaces_count = in.readChar( );   interfaces = newint[interfaces_count];   for (int i=0; i<interfaces_count; i++)   interfaces[i] = in.readChar( );   fields_count = in.readChar( );  fields = new field_info[fields_count];   for (int i=0; i<fields_count;i++) {    fields[i] = new field_info(this, in);   }   methods_count =in.readChar( );   methods = new method_info[methods_count];   for (inti=0; i<methods_count; i++) {    methods[i] = new method_info(this, in);  }   attributes_count = in.readChar( );   attributes = newattribute_info[attributes_count];   for (int i=0; i<attributes_count;i++){    in.mark(2);    String s = constant_pool[in.readChar()].toString( );    in.reset( );    if (s.equals(“SourceFile”))    attributes[i] = new SourceFile_attribute(this, in);    else if(s.equals(“Deprecated”))     attributes[i] = newDeprecated_attribute(this, in);    else if (s.equals(“InnerClasses”))    attributes[i] = new InnerClasses_attribute(this, in);    else    attributes[i] = new attribute_info.Unknown(this, in);   }  }  /**Serializes the ClassFile object into a byte stream. */  public voidserialize (OutputStream o)   throws IOException{   DataOutputStream out= (o instanceof DataOutputStream ?    (DataOutputStream) o : newDataOutputStream(o));   out.writeInt(magic);  out.writeChar(minor_version);   out.writeChar(major_version);  out.writeChar(constant_pool_count);   for (int i=1;i<constant_pool_count; i++){    constant_pool[i].serialize(out);    if(constant_pool[i] instanceof CONSTANT_Long_info ∥      constant_pool[i]instanceof CONSTANT_Double_info)     i++;   }  out.writeChar(access_flags);   out.writeChar(this_class);  out.writeChar(super_class);   out.writeChar(interfaces_count);   for(int i=0; i<interfaces_count; i++)    out.writeChar(interfaces[i]);  out.writeChar(fields_count);   for (int i=0; i<fields_count; i++)   fields[i].serialize(out);   out.writeChar(methods_count);   for (inti=0; i<methods_count; i++)    methods[i].serialize(out);  out.writeChar(attributes_count);   for (int i=0; i<attributes_count;i++)    attributes[i].serialize(out);   // Flush the outputstream justto make sure.   out.flush( );  } }

-   A14. Code_attribute.java

Convience class for representing Code_attribute structures withinClassFiles. import java.util.*; import java.lang.*; import java.io.*;/**  * The code[ ] is stored as a 2D array.  */ public final classCode_attribute extends attribute_info{  public int max_stack;  publicint max_locals;  public int code_length;  public byte[ ][ ] code; public int exception_table_length;  public exception_table[ ]exception_table;  public int attributes_count;  public attribute_info[ ]attributes;  /** Internal class that handles the exception table. */ public final static class exception_table{   public int start_pc;  public int end_pc;   public int handler_pc;   public int catch_type; }  /** Constructor called only by method_info. */ Code_attribute(ClassFile cf, int ani, int al, int ms, int ml, int cl,    byte[ ][ ] cd, int etl, exception_table[ ] et, int ac,    attribute_info[ ] a){   super(cf);   attribute_name_index = ani;  attribute_length = al;   max_stack = ms;   max_locals = ml;  code_length = cl;   code = cd;   exception_table_length = etl;  exception_table = et;   attributes_count = ac;   attributes = a;  } /** Used during input serialization by ClassFile only. */ Code_attribute(ClassFile cf, DataInputStream in)   throws IOException{  super(cf, in);   max_stack = in.readChar( );   max_locals =in.readChar( );   code_length = in.readInt( );   code = newbyte[code_length][ ];   int i = 0;   for (int pos=0; pos<code_length;i++){    in.mark(1);    int s = in.read( );    in.reset( );    switch(s){     case 16:     case 18:     case 21:     case 22:     case 23:    case 24:     case 25:     case 54:     case 55:     case 56:    case 57:     case 58:     case 169:     case 188:     case 196:     code[i] = new byte[2];      break;     case 17:     case 19:    case 20:     case 132:     case 153:     case 154:     case 155:    case 156:     case 157:     case 158:     case 159:     case 160:    case 161:     case 162:     case 163:     case 164:     case 165:    case 166:     case 167:     case 168:     case 178:     case 179:    case 180:     case 181:     case 182:     case 183:     case 184:    case 187:     case 189:     case 192:     case 193:     case 198:    case 199:     case 209:      code[i] = new byte[3];      break;    case 197:      code[i] = new byte[4];      break;     case 185:    case 200:     case 201:      code[i] = new byte[5];      break;    case 170:{      int pad = 3 − (pos % 4);      in.mark(pad+13); //highbyte      in.skipBytes(pad+5); // lowbyte      int low = in.readInt();      code[i] =       new byte[pad + 13 + ((in.readInt( ) − low + 1) *4)];      in.reset( );      break;     }case 171:{      int pad = 3 −(pos % 4);      in.mark(pad+9);      in.skipBytes(pad+5);      code[i] =new byte[pad + 9 + (in.readInt( ) * 8)];      in.reset( );      break;    }default:      code[i] = new byte[1];    }    in.read(code[i], 0,code[i].length);    pos += code[i].length;   }   // adjust the array tothe new size and store the size   byte[ ][ ] temp = new byte[i][ ];  System.arraycopy(code, 0, temp, 0, i);   code = temp;  exception_table_length = in.readChar( );   exception_table =    newCode_attribute.exception_table[exception_table_length];   for (i=0;i<exception_table_length; i++){    exception_table[i] = newexception_table( );    exception_table[i].start_pc = in.readChar( );   exception_table[i].end_pc = in.readChar( );   exception_table[i].handler_pc = in.readChar( );   exception_table[i].catch_type = in.readChar( );   }  attributes_count = in.readChar( );   attributes = newattribute_info[attributes_count];   for (i=0; i<attributes_count; i++){   in.mark(2);    String s = cf.constant_pool[in.readChar( )].toString();    in.reset( );    if (s.equals(“LineNumberTable”))     attributes[i]= new LineNumberTable_attribute(cf, in);    else if(s.equals(“LocalVariableTable”))     attributes[i] = newLocalVariableTable_attribute(cf, in);    else     attributes[i] = newattribute_info.Unknown(cf, in);   } } /** Used during outputserialization by ClassFile only. */ void serialize(DataOutputStream out) throws IOException{   attribute_length = 12 + code_length +   (exception_table_length * 8);   for (int i=0; i<attributes_count;i++)    attribute_length += attributes[i].attribute_length + 6;  super.serialize(out);   out.writeChar(max_stack);  out.writeChar(max_locals);   out.writeInt(code_length);   for (inti=0, pos=0; pos<code_length; i++){    out.write(code[i], 0,code[i].length);    pos += code[i].length;   }  out.writeChar(exception_table_length);   for (int i=0;i<exception_table_length; i++){   out.writeChar(exception_table[i].start_pc);   out.writeChar(exception_table[i].end_pc);   out.writeChar(exception_table[i].handler_pc);   out.writeChar(exception_table[i].catch_type);   }  out.writeChar(attributes_count);   for (int i=0; i<attributes_count;i++)    attributes[i].serialize(out);  } }

-   A15. CONSTANT_Class_info.java

Convience class for representing CONSTANT_Class_info structures withinClassFiles. import java.lang.*; import java.io.*; /** Class subtype of aconstant pool entry. */ public final class CONSTANT_Class_info extendscp_info{  /** The index to the name of this class. */  public intname_index = 0;  /** Convenience constructor.   */  publicCONSTANT_Class_info(int index) {   tag = 7;   name_index = index;  } /** Used during input serialization by ClassFile only. */ CONSTANT_Class_info(ClassFile cf, DataInputStream in)   throwsIOException{   super(cf, in);   if (tag != 7)    throw newClassFormatError( );   name_index = in.readChar( );  }  /** Used duringoutput serialization by ClassFile only. */  voidserialize(DataOutputStream out)   throws IOException{  out.writeByte(tag);   out.writeChar(name_index);  } }

A16. CONSTANT_Double_info.java import java.lang.*; import java.io.*; /**Double subtype of a constant pool entry. */ public final classCONSTANT_Double_info extends cp_info{  /** The actual value. */  publicdouble bytes;  public CONSTANT_Double_info(double d){   tag = 6;   bytes= d;  }  /** Used during input serialization by ClassFile only. */ CONSTANT_Double_info(ClassFile cf, DataInputStream in)   throwsIOException{   super(cf, in);   if (tag != 6)    throw newClassFormatError( );   bytes = in.readDouble( );  }  /** Used duringoutput serialization by ClassFile only. */  voidserialize(DataOutputStream out)   throws IOException{  out.writeByte(tag);   out.writeDouble(bytes);   long l =Double.doubleToLongBits(bytes);  } }

-   A17. CONSTANT_Fieldref_info.java

Convience class for representing CONSTANT_Fieldref_info structureswithin ClassFiles. import java.lang.*; import java.io.*; /** Fieldrefsubtype of a constant pool entry. */ public final classCONSTANT_Fieldref_info extends cp_info{  /** The index to the class thatthis field is referencing to. */  public int class_index;  /** The nameand type index this field if referencing to. */  public intname_and_type_index;  /** Convenience constructor. */  publicCONSTANT_Fieldref_info(int class_index,  int name_and_type_index) {  tag = 9;   this.class_index = class_index;   this.name_and_type_index= name_and_type_index;  }  /** Used during input serialization byClassFile only. */  CONSTANT_Fieldref_info(ClassFile cf, DataInputStreamin)   throws IOException{   super(cf, in);   if (tag != 9)    throw newClassFormatError( );   class_index = in.readChar( );  name_and_type_index = in.readChar( );  }  /** Used during outputserialization by ClassFile only. */  void serialize(DataOutputStreamout)   throws IOException{   out.writeByte(tag);  out.writeChar(class_index);   out.writeChar(name_and_type_index);  } }

-   A18. CONSTANT_Float_info.java

Convience class for representing CONSTANT_Float_info structures withinClassFiles. import java.lang.*; import java.io.*; /** Float subtype of aconstant pool entry. */ public final class CONSTANT_Float_info extendscp_info{  /** The actual value. */  public float bytes;  publicCONSTANT_Float_info(float f){   tag = 4;   bytes = f;  }  /** Usedduring input serialization by ClassFile only. */ CONSTANT_Float_info(ClassFile cf, DataInputStream in)   throwsIOException{   super(cf, in);   if (tag != 4)    throw newClassFormatError( );   bytes = in.readFloat( );  }  /** Used duringoutput serialization by ClassFile only. */  public voidserialize(DataOutputStream out)   throws IOException{  out.writeByte(4);   out.writeFloat(bytes);  } }

-   A19. CONSTANT_Integer_info.java

Convience class for representing CONSTANT_Integer_info structures withinClassFiles. import java.lang.*; import java.io.*; /** Integer subtype ofa constant pool entry. */ public final class CONSTANT_Integer_infoextends cp_info{  /** The actual value. */  public int bytes;  publicCONSTANT_Integer_info(int b) {   tag = 3;   bytes = b;  }  /** Usedduring input serialization by ClassFile only. */ CONSTANT_Integer_info(ClassFile cf, DataInputStream in)   throwsIOException{   super(cf, in);   if (tag != 3)    throw newClassFormatError( );   bytes = in.readInt( );  }  /** Used during outputserialization by ClassFile only. */  public voidserialize(DataOutputStream out)   throws IOException{  out.writeByte(tag);   out.writeInt(bytes);  } }

-   A20. CONSTANT_InterfaceMethodref_info.java

Convience class for representing CONSTANT_InterfaceMethodref_infostructures within ClassFiles. import java.lang.*; import java.io.*; /**InterfaceMethodref subtype of a constant pool entry. */ public finalclass CONSTANT_InterfaceMethodref_info extends cp_info{  /** The indexto the class that this field is referencing to. */  public intclass_index;  /** The name and type index this field if referencing to.*/  public int name_and_type_index;  publicCONSTANT_InterfaceMethodref_info(int class_index,            intname_and_type_index) {   tag = 11;   this.class_index = class_index;  this.name_and_type_index = name_and_type_index;  }  /** Used duringinput serialization by ClassFile only. */ CONSTANT_InterfaceMethodref_info(ClassFile cf,  DataInputStream in)  throws IOException{   super(cf, in);   if (tag != 11)    throw newClassFormatError( );   class_index = in.readChar( );  name_and_type_index = in.readChar( );  }  /** Used during outputserialization by ClassFile only. */  void serialize(DataOutputStreamout)   throws IOException{   out.writeByte(tag);  out.writeChar(class_index);   out.writeChar(name_and_type_index);  } }

-   A21. CONSTANT_Long_info.java

Convience class for representing CONSTANT_Long_info structures withinClassFiles. import java.lang.*; import java.io.*; /** Long subtype of aconstant pool entry. */ public final class CONSTANT_Long_info extendscp_info{   /** The actual value. */   public long bytes;   publicCONSTANT_Long_info(long b){     tag = 5;     bytes = b;   }   /** Usedduring input serialization by ClassFile only. */  CONSTANT_Long_info(ClassFile cf, DataInputStream in)     throwsIOException{     super(cf, in);     if (tag != 5)       throw newClassFormatError( );     bytes = in.readLong( );   }   /** Used duringoutput serialization by ClassFile only. */   voidserialize(DataOutputStream out)     throws IOException{    out.writeByte(tag);     out.writeLong(bytes);   } }

-   A22. CONSTANT_Methodref_info.java

Convience class for representing CONSTANT_Methodref_info structureswithin ClassFiles. import java.lang.*; import java.io.*; /** Methodrefsubtype of a constant pool entry.  */ public final classCONSTANT_Methodref_info extends cp_info{   /** The index to the classthat this field is referencing to. */   public int class_index;   /**The name and type index this field if referencing to. */   public intname_and_type_index;   public CONSTANT_Methodref_info(int class_index,  int name_and_type_index) {     tag = 10;     this.class_index =class_index;     this.name_and_type_index = name_and_type_index;   }  /** Used during input serialization by ClassFile only. */  CONSTANT_Methodref_info(ClassFile cf, DataInputStream in)     throwsIOException{     super(cf, in);     if (tag != 10)       throw newClassFormatError( );     class_index = in.readChar( );    name_and_type_index = in.readChar( );   }   /** Used during outputserialization by ClassFile only. */   void serialize(DataOutputStreamout)     throws IOException{     out.writeByte(tag);    out.writeChar(class_index);     out.writeChar(name_and_type_index);  } }

-   A23. CONSTANT_NameAndType_info.java

Convience class for representing CONSTANT_NameAndType_info structureswithin ClassFiles. import java.io.*; import java.lang.*; /** NameAndTypesubtype of a constant pool entry.  */ public final classCONSTANT_NameAndType_info extends cp_info{  /** The index to the Utf8that contains the name. */  public int name_index;  /** The index fo theUtf8 that constains the signature. */  public int descriptor_index; public CONSTANT_NameAndType_info(int name_index,  int descriptor_index){   tag = 12;   this.name_index = name_index;   this.descriptor_index =descriptor_index;  }  /** Used during input serialization by ClassFileonly. */  CONSTANT_NameAndType_info(ClassFile cf, DataInputStream in)  throws IOException{   super(cf, in);   if (tag != 12)    throw newClassFormatError( );   name_index = in.readChar( );   descriptor_index =in.readChar( );  }  /** Used during output serialization by ClassFileonly. */  void serialize(DataOutputStream out)   throws IOException{  out.writeByte(tag);   out.writeChar(name_index);  out.writeChar(descriptor_index);  } }

-   A24. CONSTANT_String_info.java

Convience class for representing CONSTANT_String_info structures withinClassFiles. import java.lang.*; import java.io.*; /** String subtype ofa constant pool entry.  */ public final class CONSTANT_String_infoextends cp_info{   /** The index to the actual value of the string. */  public int string_index;   public CONSTANT_String_info(int value) {    tag = 8;     string_index = value;   }   /** ONLY TO BE USED BYCLASSFILE! */   public CONSTANT_String_info(ClassFile cf,DataInputStream in)     throws IOException{     super(cf, in);     if(tag != 8)       throw new ClassFormatError( );     string_index =in.readChar( );   }   /** Output serialization, ONLY TO BE USED BYCLASSFILE! */   public void serialize(DataOutputStream out)     throwsIOException{     out.writeByte(tag);     out.writeChar(string_index);  } }

-   A25. CONSTANT_Utf8_info.java

Convience class for representing CONSTANT_Utf8_info structures withinClassFiles. import java.io.*; import java.lang.*; /** Utf8 subtype of aconstant pool entry.  *  We internally represent the Utf8 info bytearray  *  as a String.  */ public final class CONSTANT_Utf8_info extendscp_info{  /** Length of the byte array. */  public int length;  /** Theactual bytes, represented by a String. */  public String bytes;  /**This constructor should be used for the purpose   *  of part creation.It does not set the parent   *  ClassFile reference.   */  publicCONSTANT_Utf8_info(String s) {   tag = 1;   length = s.length( );  bytes = s;  }  /** Used during input serialization by ClassFile only.*/  public CONSTANT_Utf8_info(ClassFile cf, DataInputStream in)   throwsIOException{   super(cf, in);   if (tag != 1)    throw newClassFormatError( );   length = in.readChar( );   byte[ ] b = newbyte[length];   in.read(b, 0, length);   // WARNING: String constructoris deprecated.   bytes = new String(b, 0, length);  }  /** Used duringoutput serialization by ClassFile only. */  public voidserialize(DataOutputStream out)   throws IOException{  out.writeByte(tag);   out.writeChar(length);   // WARNING: Handling ofString coversion here might be   problematic.   out.writeBytes(bytes); }  public String toString( ){   return bytes;  } }

-   A26. ConstantValue_attribute.java

Convience class for representing ConstantValue_attribute structureswithin ClassFiles. import java.lang.*; import java.io.*; /** Attributethat allows for initialization of static variables in  *  classes. Thisattribute will only reside in a field_info struct.  */ public finalclass ConstantValue_attribute extends attribute_info{   public intconstantvalue_index;   public ConstantValue_attribute(ClassFile cf, intani, int al, int cvi){     super(cf);     attribute_name_index = ani;    attribute_length = al;     constantvalue_index = cvi;   }   publicConstantValue_attribute(ClassFile cf, DataInputStream in)     throwsIOException{     super(cf, in);     constantvalue_index = in.readChar();   }   public void serialize(DataOutputStream out)     throwsIOException{     attribute_length = 2;     super.serialize(out);    out.writeChar(constantvalue_index);   } }

-   A27. cp_info.java

Convience class for representing cp_info structures within ClassFiles.import java.lang.*; import java.io.*; /** Represents the commoninterface of all constant pool parts  *  that all specific constant poolitems must inherit from.  *  */ public abstract class cp_info{   /** Thetype tag that signifies what kind of constant pool    *  item it is */  public int tag;   /** Used for serialization of the object back into abytestream. */   abstract void serialize(DataOutputStream out) throwsIOException;   /** Default constructor. Simply does nothing. */   publiccp_info( ) { }   /** Constructor simply takes in the ClassFile as areference to    *  it's parent    */   public cp_info(ClassFile cf) { }  /** Used during input serialization by ClassFile only. */  cp_info(ClassFile cf, DataInputStream in)     throws IOException{    tag = in.readUnsignedByte( );   } }

-   A28. Deprecated_attribute.java

Convience class for representing Deprecated_attribute structures withinClassFiles. import java.lang.*; import java.io.*; /** A fix attributedthat can be located either in the ClassFile,  *  field_info or themethod_info attribute. Mark deprecated to  *  indicate that the method,class or field has been superceded.  */ public final classDeprecated_attribute extends attribute_info{   publicDeprecated_attribute(ClassFile cf, int ani, int al){     super(cf);    attribute_name_index = ani;     attribute_length = al;   }   /**Used during input serialization by ClassFile only. */  Deprecated_attribute(ClassFile cf, DataInputStream in)     throwsIOException{     super(cf, in);   } }

-   A29. Exceptions_attribute.java

Convience class for representing Exceptions_attribute structures withinClassFiles. import java.lang.*; import java.io.*; /** This is the structwhere the exceptions table are located.  *  <br><br>  *  This attributecan only appear once in a method_info struct.  */ public final classExceptions_attribute extends attribute_info{   public intnumber_of_exceptions;   public int[ ] exception_index_table;   publicExceptions_attribute(ClassFile cf, int ani, int al, int noe,            int[ ] eit){     super(cf);     attribute_name_index = ani;    attribute_length = al;     number_of_exceptions = noe;    exception_index_table = eit;   }   /** Used during inputserialization by ClassFile only. */   Exceptions_attribute(ClassFile cf,DataInputStream in)     throws IOException{     super(cf, in);    number_of_exceptions = in.readChar( );     exception_index_table =new int[number_of_exceptions];     for (int i=0; i<number_of_exceptions;i++)       exception_index_table[i] = in.readChar( );   }   /** Usedduring output serialization by ClassFile only. */   public voidserialize(DataOutputStream out)     throws IOException{    attribute_length = 2 + (number_of_exceptions*2);    super.serialize(out);     out.writeChar(number_of_exceptions);    for (int i=0; i<number_of_exceptions; i++)      out.writeChar(exception_index_table[i]);   } }

-   A30. field_info.java

Convience class for representing field_info structures withinClassFiles. import java.lang.*; import java.io.*; /**  Represents thefield_info structure as specified in the JVM specification.  */ publicfinal class field_info{   public int access_flags;   public intname_index;   public int descriptor_index;   public intattributes_count;   public attribute_info[ ] attributes;   /**Convenience constructor. */   public field_info(ClassFile cf, int flags,int ni, int di){     access_flags = flags;     name_index = ni;    descriptor_index = di;     attributes_count = 0;     attributes =new attribute_info[0];   }   /** Constructor called only during theserialization process.    *  <br><br>    *  This is intentionally leftas package protected as we    *  should not normally call thisconstructor directly.    *  <br><br>    *  Warning: the handling of lenis not correct (after String s =...)    */   field_info(ClassFile cf,DataInputStream in)     throws IOException{     access_flags =in.readChar( );     name_index = in.readChar( );     descriptor_index =in.readChar( );     attributes_count = in.readChar( );     attributes =new attribute_info[attributes_count];     for (int i=0;i<attributes_count; i++){       in.mark(2);       String s =cf.constant_pool[in.readChar( )].toString( );       in.reset( );      if (s.equals(“ConstantValue”))         attributes[i] = newConstantValue_attribute(cf, in);       else if (s.equals(“Synthetic”))        attributes[i] = new Synthetic_attribute(cf, in);       else if(s.equals(“Deprecated”))         attributes[i] = newDeprecated_attribute(cf, in);       else         attributes[i] = newattribute_info.Unknown(cf, in);     }   }   /** To serialize thecontents into the output format.    */   public voidserialize(DataOutputStream out)     throws IOException{    out.writeChar(access_flags);     out.writeChar(name_index);    out.writeChar(descriptor_index);    out.writeChar(attributes_count);     for (int i=0;i<attributes_count; i++)       attributes[i].serialize(out);   } }

-   A31. InnerClasses_attribute.java

Convience class for representing InnerClasses_attribute structureswithin ClassFiles. import java.lang.*; import java.io.*; /** A variablelength structure that contains information about an  *  inner class ofthis class.  */ public final class InnerClasses_attribute extendsattribute_info{  public int number_of_classes;  public classes[ ]classes;  public final static class classes{   intinner_class_info_index;   int outer_class_info_index;   intinner_name_index;   int inner_class_access_flags;  }  publicInnerClasses_attribute(ClassFile cf, int ani, int al,        int noc,classes[ ] c){   super(cf);   attribute_name_index = ani;  attribute_length = al;   number_of_classes = noc;   classes = c;  } /** Used during input serialization by ClassFile only. */ InnerClasses_attribute(ClassFile cf, DataInputStream in)   throwsIOException{   super(cf, in);   number_of_classes = in.readChar( );  classes = new InnerClasses_attribute.classes[number_of_classes];   for(int i=0; i<number_of_classes; i++){    classes[i] = new classes( );   classes[i].inner_class_info_index = in.readChar( );   classes[i].outer_class_info_index = in.readChar( );   classes[i].inner_name_index = in.readChar( );   classes[i].inner_class_access_flags = in.readChar( );   }  }  /**Used during output serialization by ClassFile only. */  public voidserialize(DataOutputStream out)   throws IOException{   attribute_length= 2 + (number_of_classes * 8);   super.serialize(out);  out.writeChar(number_of_classes);   for (int i=0; i<number_of_classes;i++){    out.writeChar(classes[i].inner_class_info_index);   out.writeChar(classes[i].outer_class_info_index);   out.writeChar(classes[i].inner_name_index);   out.writeChar(classes[i].inner_class_access_flags);   }  } }

-   A32. LineNumberTable_attribute.java

Convience class for representing LineNumberTable_attribute structureswithin ClassFiles. import java.lang.*; import java.io.*; /** Determineswhich line of the binary code relates to the  *  corresponding sourcecode.  */ public final class LineNumberTable_attribute extendsattribute_info{  public int line_number_table_length;  publicline_number_table[ ] line_number_table;  public final static classline_number_table{   int start_pc;   int line_number;  }  publicLineNumberTable_attribute(ClassFile cf, int ani, int al, int lntl,         line_number_table[ ] lnt){   super(cf);   attribute_name_index= ani;   attribute_length = al;   line_number_table_length = lntl;  line_number_table = lnt;  }  /** Used during input serialization byClassFile only. */  LineNumberTable_attribute(ClassFile cf,DataInputStream in)   throws IOException{   super(cf, in);  line_number_table_length = in.readChar( );   line_number_table = newLineNumberTable_attribute.line_number_table [line_number_table_length];  for (int i=0; i<line_number_table_length; i++){   line_number_table[i] = new line_number_table( );   line_number_table[i].start_pc = in.readChar( );   line_number_table[i].line_number = in.readChar( );   }  }  /** Usedduring output serialization by ClassFile only. */  voidserialize(DataOutputStream out)   throws IOException{   attribute_length= 2 + (line_number_table_length * 4);   super.serialize(out);  out.writeChar(line_number_table_length);   for (int i=0;i<line_number_table_length; i++){   out.writeChar(line_number_table[i].start_pc);   out.writeChar(line_number_table[i].line_number);   }  } }

-   A33. LocalVariableTable_attribute.java

Convience class for representing LocalVariableTable_attribute structureswithin ClassFiles. import java.lang.*; import java.io.*; /** Used bydebugger to find out how the source file line number is linked  *  tothe binary code. It has many to one correspondence and is found in  * the Code_attribute.  */ public final class LocalVariableTable_attributeextends attribute_info{  public int local_variable_table_length;  publiclocal_variable_table[ ] local_variable_table;  public final static classlocal_variable_table{   int start_pc;   int length;   int name_index;  int descriptor_index;   int index;  }  publicLocalVariableTable_attribute(ClassFile cf, int ani, int al,          intlvtl, local_variable_table[ ] lvt){   super(cf);   attribute_name_index= ani;   attribute_length = al;   local_variable_table_length = lvtl;  local_variable_table = lvt;  }  /** Used during input serialization byClassFile only. */  LocalVariableTable_attribute(ClassFile cf,DataInputStream in)   throws IOException{   super(cf, in);  local_variable_table_length = in.readChar( );   local_variable_table =new  LocalVariableTable_attribute.local_variable_table [local_variable_table_length];   for (int i=0;i<local_variable_table_length; i++){    local_variable_table[i] = newlocal_variable_table( );    local_variable_table[i].start_pc =in.readChar( );    local_variable_table[i].length = in.readChar( );   local_variable_table[i].name_index = in.readChar( );   local_variable_table[i].descriptor_index = in.readChar( );   local_variable_table[i].index = in.readChar( );   }  }  /** Usedduring output serialization by ClassFile only. */  voidserialize(DataOutputStream out)   throws IOException{   attribute_length= 2 + (local_variable_table_length * 10);   super.serialize(out);  out.writeChar(local_variable_table_length);   for (int i=0;i<local_variable_table_length; i++){   out.writeChar(local_variable_table[i].start_pc);   out.writeChar(local_variable_table[i].length);   out.writeChar(local_variable_table[i].name_index);   out.writeChar(local_variable_table[i].descriptor_index);   out.writeChar(local_variable_table[i].index);   }  } }

-   A34. method_info.java

Convience class for representing method_info structures withinClassFiles. import java.lang.*; import java.io.*; /** This follows themethod_info in the JVM specification.  */ public final class method_info{  public int access_flags;  public int name_index;  public intdescriptor_index;  public int attributes_count;  public attribute_info[] attributes;  /** Constructor. Creates a method_info, initializes itwith   *  the flags set, and the name and descriptor indexes given.   * A new uninitialized code attribute is also created, and stored   *  inthe <i>code</i> variable.*/  public method_info(ClassFile cf, int flags,int ni, int di,        int ac, attribute_info[ ] a) {   access_flags =flags;   name_index = ni;   descriptor_index = di;   attributes_count =ac;   attributes = a;  }  /** This method creates a method_info from thecurrent pointer in the   *  data stream. Only called by during theserialization of a complete   *  ClassFile from a bytestream, notnormally invoked directly.   */  method_info(ClassFile cf,DataInputStream in)   throws IOException{   access_flags = in.readChar();   name_index = in.readChar( );   descriptor_index = in.readChar( );  attributes_count = in.readChar( );   attributes = newattribute_info[attributes_count];   for (int i=0; i<attributes_count;i++){    in.mark(2);    String s = cf.constant_pool[in.readChar()].toString( );    in.reset( );    if (s.equals(“Code”))    attributes[i] = new Code_attribute(cf, in);    else if(s.equals(“Exceptions”))     attributes[i] = newExceptions_attribute(cf, in);    else if (s.equals(“Synthetic”))    attributes[i] = new Synthetic_attribute(cf, in);    else if(s.equals(“Deprecated”))     attributes[i] = newDeprecated_attribute(cf, in);    else     attributes[i] = newattribute_info.Unknown(cf, in);   }  }  /** Output serialization of themethod_info to a byte array.   *  Not normally invoked directly.  */ public void serialize(DataOutputStream out)   throws IOException{  out.writeChar(access_flags);   out.writeChar(name_index);  out.writeChar(descriptor_index);   out.writeChar(attributes_count);  for (int i=0; i<attributes_count; i++)   attributes[i].serialize(out);  } }

-   A35. SourceFile_attribute.java

Convience class for representing SourceFile_attribute structures withinClassFiles. import java.lang.*; import java.io.*; /** A SourceFileattribute is an optional fixed_length attribute in  *  the attributestable. Only located in the ClassFile struct only  *  once.  */ publicfinal class SourceFile_attribute extends attribute_info{  public intsourcefile_index;  public SourceFile_attribute(ClassFile cf, int ani,int al, int sfi){   super(cf);   attribute_name_index = ani;  attribute_length = al;   sourcefile_index = sfi;  }  /** Used duringinput serialization by ClassFile only. */ SourceFile_attribute(ClassFile cf, DataInputStream in)   throwsIOException{   super(cf, in);   sourcefile_index = in.readChar( );  } /** Used during output serialization by ClassFile only. */  voidserialize(DataOutputStream out)   throws IOException{   attribute_length= 2;   super.serialize(out);   out.writeChar(sourcefile_index);  } }

-   A36. Synthetic_attribute.java

Convience class for representing Synthetic_attribute structures withinClassFiles. import java.lang.*; import java.io.*; /** A syntheticattribute indicates that this class does not have  *  a generated codesource. It is likely to imply that the code  *  is generated by machinemeans rather than coded directly. This  *  attribute can appear in theclassfile, method_info or field_info.  *  It is fixed length.  */ publicfinal class Synthetic_attribute extends attribute_info{  publicSynthetic_attribute(ClassFile cf, int ani, int al){   super(cf);  attribute_name_index = ani;   attribute_length = al;  }  /** Usedduring output serialization by ClassFile only. */  Synthetic_attribute(ClassFile cf, DataInputStream in)   throws IOException{   super(cf,in);  } }

Annexure D1

Method void run( )  0 getstatic #2 <Field java.lang.Object LOCK>  3 dup 4 astore_1  5 monitorenter  6 getstatic #3 <Field int counter>  9iconst_1 10 iadd 11 putstatic #3 <Field int counter> 14 aload_1 15monitorexit 16 return

Annexure D2

Method void run( )  0 getstatic #2 <Field java.lang.Object LOCK>  3 dup 4 astore_1  5 dup  6 monitorenter  7 invokestatic #23 <Method voidacquireLock(java.lang.Object)> 10 getstatic #3 <Field int counter> 13iconst_1 14 iadd 15 putstatic #3 <Field int counter> 18 aload_1 19 dup20 invokestatic #24 <Method void releaseLock(java.lang.Object)> 23monitorexit 24 return

Annexure D3

import java.lang.*; public class example{  /** Shared static field. */ public final static Object LOCK = new Object( );  /** Shared staticfield. */  public static int counter = 0;  /** Example method usingsynchronization. This method serves to     illustrate the use ofsynchronization to implement thread-safe     modification of a sharedmemory location by potentially multiple     threads. */  public voidrun( ){   // First acquire the lock, otherwise any memory writes we dowill be   // prone to race-conditions.   synchronized (LOCK){    // Nowthat we have acquired the lock, we can safely modify    // memory in athread-safe manner.    counter++;   }  } }

Annexure D4

import java.lang.*; import java.util.*; import java.net.*; importjava.io.*; public class LockClient{  /** Protocol specific values. */ public final static int CLOSE = −1;  public final static int NACK = 0; public final static int ACK = 1;  public final static int ACQUIRE_LOCK= 10;  public final static int RELEASE_LOCK = 20;  /** LockServernetwork values. */  public final static String serverAddress =  System.getProperty(“LockServer_network_address”);  public final staticint serverPort =  Integer.parseInt(System.getProperty(“LockServer_network_port”));  /**Table of global ID's for local objects. (hashcode-to-globalID    mappings) */  public final static Hashtable hashCodeToGlobalID = newHashtable( );  /** Called when an application is to acquire a lock. */ public static void acquireLock(Object o){   // First of all, we need toresolve the globalID for object ‘o’.   // To do this we use thehashCodeToGlobalID table.   int globalID = ((Integer)hashCodeToGlobalID.get(o)).intValue( );   try{    // Next, we want toconnect to the LockServer, which will grant us    // the global lock.   Socket socket = new Socket(serverAddress, serverPort);   DataOutputStream out =    newDataOutputStream(socket.getOutputStream( ));   DataInputStream in = new  DataInputStream(socket.getInputStream( ));   // Ok, now send theserialized request to the lock server.   out.writeInt(ACQUIRE_LOCK);  out.writeInt(globalID);   out.flush( );   // Now wait for the reply.  int status = in.readInt( ); // This is a blocking call. So we // willwait until the remote side // sends something.   if (status == NACK){   throw new AssertionError(     “Negative acknowledgement. Requestfailed.”);   }else if (status != ACK){    throw newAssertionError(“Unknown acknowledgement: ” +     status + “. Requestfailed.”);   }   // Close down the connection.   out.writeInt(CLOSE);  out.flush( );   out.close( );   in.close( );   socket.close( );   //Make sure to close the socket.   // This is a good acknowledgement, thuswe can return now because   // global lock is now acquired.   return; }catch (IOException e){   throw new AssertionError(“Exception: ” +e.toString( ));  } } /* Called when an application is to release a lock.*/ public static void releaseLock(Object o){  // First of all, we needto resolve the globalID for object ‘o’.  // To do this we use thehashCodeToGlobalID table.  int globalID = ((Integer)hashCodeToGlobalID.get(o)).intValue( );  try{   // Next, we want toconnect to the LockServer, which records us as   // the owner of theglobal lock for object ‘o’.   Socket socket = new Socket (serverAddress,serverPort);   DataOutputStream out =    newDataOutputStream(socket.getOutputStream( ));   DataInputStream in =  new DataInputStream(socket.getInputStream( ));   // Ok, now send theserialized request to the lock server.   out.writeInt(RELEASE_LOCK);  out.writeInt(globalID);   out.flush( );   // Now wait for the reply.  int status = in.readInt( ); // This is a blocking call. So we // willwait until the remote side // sends something.   if (status == NACK){   throw new AssertionError(     “Negative acknowledgement. Requestfailed.”);   }else if (status != ACK){    throw newAssertionError(“Unknown acknowledgement: ” +     status + “. Requestfailed.”);   }   // Close down the connection.   out.writeInt(CLOSE);  out.flush( );   out.close( );   in.close( );   socket.close( );   //Make sure to close the socket.   // This is a good acknowledgement,return hecause global lock is   // now released.   return;  }catch(IOException e){   throw new AssertionError(“Exception: ” + e.toString());  }  } }

Annexure D5

 import java.lang.*;  import java.util.*;  import java.net.*;  importjava.io.*;  public class LockServer implements Runnable{   /** Protocolspecific values */   public final static int CLOSE = −1;   public finalstatic int NACK = 0;   public final static int ACK = 1;   public finalstatic int ACQUIRE_LOCK = 10;   public final static int RELEASE_LOCK =20;   /** LockServer network values. */   public final static intserverPort = 20001;   /** Table of lock records. */   public finalstatic Hashtable locks = new Hashtable( );   /** Linked list of waitingLockManager objects. */   public LockServer next = null;   /** Addressof remote LockClient. */   public final String address;   /** Privateinput/output objects. */   private Socket socket = null;   privateDataOutputStream outputStream;   private DataInputStream inputStream;  public static void main(String[ ] s)  throws Exception{  System.out.println(“LockServer_network_address=” +   InetAddress.getLocalHost( ).getHostAddress( ));  System.out.println(“LockServer_network_port=” + serverPort);   //Create a serversocket to accept incoming lock operation   //connections.   ServerSocket serverSocket = new ServerSocket(serverPort);  while (!Thread.interrupted( )){    // Block until an incoming lockoperation connection.    Socket socket = serverSocket.accept( );    //Create a new instance of LockServer to manage this lock    // operationconnection.    new Thread(new LockServer(socket)).start( );   }  }  /**Constructor. Initialise this new LockServer instance with necessary   resources for operation. */  public LockServer(Socket s){   socket =s;   try{    outputStream = new DataOutputStream(s.getOutputStream( ));   inputStream = new DataInputStream(s.getInputStream( ));    address =s.getInetAddress( ).getHostAddress( );   }catch (IOException e){   throw new AssertionError(“Exception: ” + e.toString( ));   }  }  /**Main code body. Decode incoming lock operation requests and    executeaccordingly. */  public void run( ){   try{    // All commands areimplemented as 32bit integers.  // Legal commands are listed in the“protocol specific values”  // fields above.  int command =inputStream.readInt( );  // Continue processing commands until a CLOSEoperation.  while (command != CLOSE){   if (command == ACQUIRE_LOCK) {  // This is an   // ACQUIRE_LOCK   // operation.    // Read in theglobalID of the object to be locked.    int globalID =inputStream.readInt( );    // Synchronize on the locks table in order toensure thread-    // safety.    synchronized (locks){     // Check foran existing owner of this lock.     LockServer lock = (LockServer)locks.get(      new Integer(globalID));     if (lock == null){  //No-one presently owns this lock,  // so acquire it.      locks.put(newInteger(globalID), this);      acquireLock( );  // Signal to the clientthe  // successful acquisition of this  // lock.     }else{  // Alreadyowned. Append ourselves  // to end of queue.      // Search for the endof the queue. (Implemented as      // linked-list)      while (lock.next!= null){       lock = lock.next;      }      lock.next = this; //Append this lock request at end.     }    }   }else if (command ==RELEASE_LOCK){  // This is a  // RELEASE_LOCK  // operation.    // Readin the globalID of the object to be locked.    int globalID =inputStream.readInt( );    // Synchronize on the locks table in order toensure thread-    // safety.    synchronized (locks){     // Check tomake sure we are the owner of this lock.     LockServer lock =(LockServer) locks.get(      new Integer(globalID));     if (lock ==null){      throw new AssertionError(“Unlocked. Release failed.”);    }else if (lock.address != this.address){      throw newAssertionError(“Trying to release a lock “ +       ”which this clientdoesn't own. Release “ +       ”failed.”);     }     lock = lock.next;    lock.acquireLock( );  // Signal to the client the  // successfulacquisition of this  // lock.     // Shift the linked list of pendingacquisitions forward     // by one.     locks.put(new Integer(globalID),lock);     // Clear stale reference.     next = null;    }   releaseLock( );  // Signal to the client the successful  // releaseof this lock.   }else{  // Unknown command.    throw new AssertionError(    “Unknown command. Operation failed.”);   }   // Read in the nextcommand.     command = inputStream.readInt( );    }   }catch (Exceptione){    throw new AssertionError(“Exception: ” + e.toString( ));  }finally{    try{     // Closing down. Cleanup this connection.    outputStream.flush( );     outputStream.close( );    inputStream.close( );     socket.close( );    }catch (Throwable t){    t.printStackTrace( );    }    // Garbage these references.   outputStream = null;    inputStream = null;    socket = null;   }  } /** Send a positive acknowledgement of an ACQUIRE_LOCK  operation. */ public void acquireLock( ) throws IOException{  outputStream.writeInt(ACK);   outputStream.flush( );  }  /** Send apositive acknowledgement of a RELEASE_LOCK  operation. */  public voidreleaseLock( ) throws IOException{   outputStream.writeInt(ACK);  outputStream.flush( );  } }

Annexure D6

This excerpt is the source-code of LockLoader, which modifies anapplications as it is being loaded. import java.lang.*; importjava.io.*; import java.net.*; public class LockLoader extendsURLClassLoader{  public LockLoader(URL[ ] urls){   super(urls);  } protected Class findClass(String name)  throws ClassNotFoundException{  ClassFile cf = null;   try{    BufferedInputStream in =     newBufferedInputStream(findResource(name.replace(‘.’,     ‘/’).concat(“.class”)).openStream( ));    cf = new ClassFile(in);   }catch (Exceptione){throw new   ClassNotFoundException(e.toString( ));}   // Class-widepointers to the enterindex and exitindex.   int enterindex = −1;   intexitindex = −1;   for (int i=0; i<cf.methods_count; i++){    for (intj=0; j<cf.methods[i].attributes_count; j++){     if(!(cf.methods[i].attributes[j] instanceof Code_attribute))     continue;     Code_attribute ca = (Code_attribute)cf.methods[i].attributes[j];     boolean changed = false;     for (intz=0; z<ca.code.length; z++){      if ((ca.code[z][0] & 0xff) == 194){ //Opcode for a // MONITORENTER // instruction.       changed = true;      // Next, realign the code array, making room for the       //insertions.       byte[ ][ ] code2 = new byte[ca.code.length+2][ ];      System.arraycopy(ca.code, 0, code2, 0, z);    code2[z+1] =ca.code[z];    System.arraycopy(ca.code, z+1, code2, z+3,    ca.code.length−(z+1));    ca.code = code2;    // Next, insert theDUP instruction.    ca.code[z] = new byte[1];    ca.code[z][0] = (byte)89;    // Finally, insert the INVOKESTATIC instruction.    if(enterindex == −1){     // This is the first time this class isencourtering the     // acquirelock instruction, so have to add it tothe     // constant pool.     cp_info[ ] cpi = newcp_info[cf.constant_pool.length+6];    System.arraycopy(cf.constant_pool, 0, cpi, 0,     cf.constant_pool.length);     cf.constant_pool = cpi;    cf.constant_pool_count += 6;     CONSTANT_Utf8_info u1 =      newCONSTANT_Utf8_info(“LockClient”);    cf.constant_pool[cf.constant_pool.length−6] = u1;    CONSTANT_Class_info c1 = new CONSTANT_Class_info(     cf.constant_pool_count−6);    cf.constant_pool[cf.constant_pool.length−5] = c1;     u1 = newCONSTANT_Utf8_info(“acquireLock”);    cf.constant_pool[cf.constant_pool.length−4] = u1;     u1 = newCONSTANT_Utf8_info(“(Ljava/lang/Object;)V”);    cf.constant_pool[cf.constant_pool.length−3] = u1;    CONSTANT_NameAndType_info n1 =      new CONSTANT_NameAndType_info(     cf.constant_pool.length−4, cf.constant_pool.length−3);    cf.constant_pool[cf.constant_pool.length−2] = n1;    CONSTANT_Methodref_info m1 = new     CONSTANT_Methodref_info(     cf.constant_pool.length−5, cf.constant_pool.length−2);    cf.constant_pool[cf.constant_pool.length−1] = m1;     enterindex =cf.constant_pool.length−1;    }    ca.code[z+2] = new byte[3];   ca.code[z+2][0] = (byte) 184;    ca.code[z+2][1] = (byte)((enterindex >> 8) & 0xff);    ca.code[z+2][2] = (byte) (enterindex &0xff);    // And lastly, increase the CODE_LENGTH and   ATTRIBUTE_LENGTH    // values.    ca.code_length += 4;   ca.attribute length += 4;    z += 1;   }else if ((ca.code[z][0] &0xff) == 195){ // Opcode for a // MONITOREXIT // instruction.    changed= true;   // Next, realign the code array, making room for the   //insertions.   byte[ ][ ] code2 = new byte[ca.code.length+2][ ];  System.arraycopy(ca.code, 0, code2, 0, z);   code2[z+1] = ca.code[z];  System.arraycopy(ca.code, z+1, code2, z+3,    ca.code.length−(z+1));  ca.code = code2;   // Next, insert the DUP instruction.   ca.code[z] =new byte[1];   ca.code[z][0] = (byte) 89;   // Finally, insert theINVOKESTATIC instruction.   if (exitindex == −1){    // This is thefirst time this class is encourtering the    // acquirelock instruction,so have to add it to the    // constant pool.    cp_info[ ] cpi = newcp_info[cf.constant_pool.length+6];   System.arraycopy(cf.constant_pool, 0, cpi, 0,    cf.constant_pool.length);    cf.constant_pool = cpi;   cf.constant_pool_count += 6;    CONSTANT_Utf8_info u1 =     newCONSTANT_Utf8_info(“LockClient”);   cf.constant_pool[cf.constant_pool.length−6] = u1;   CONSTANT_Class_info c1 = new CONSTANT_Class_info(    cf.constant_pool_count−6);   cf.constant_pool[cf.constant_pool.length−5] = c1;    u1 = newCONSTANT_Utf8_info(“releaseLock”);   cf.constant_pool[cf.constant_pool.length−4] = u1;    u1 = newCONSTANT_Utf8_info(“(Ljava/lang/Object;)V”);   cf.constant_pool[cf.constant_pool.length−3] = u1;   CONSTANT_NameAndType_info n1 =     new CONSTANT_NameAndType_info(    cf.constant_pool.length−4, cf.constant_pool.length−3);   cf.constant_pool[cf.constant_pool.length−2] = n1;   CONSTANT_Methodref_info m1 = new    CONSTANT_Methodref_info(    cf.constant_pool.length−5, cf.constant_pool.length−2);   cf.constant_pool[cf.constant_pool.length−1] = m1;    exitindex =cf.constant_pool.length−1;   }   ca.code[z+2] = new byte[3];  ca.code[z+2][0] = (byte) 184;   ca.code[z+2][1] = (byte)((exitindex >> 8) & 0xff);   ca.code[z+2][2] = (byte) (exitindex &0xff);   // And lastly, increase the CODE_LENGTH and   ATTRIBUTE_LENGTH  // values.   ca.code_length += 4;   ca.attribute length += 4;   z +=1;      }     }     // If we changed this method, then increase thestack size by one.     if (changed){      ca.max_stack++;     // Just tomake sure.     }    }   }   try{    ByteArrayOutputStream out = newByteArrayOutputStream( );    cf.serialize(out);    byte[ ] b =out.toByteArray( );    return defineClass(name, b, 0, b.length);  }catch (Exception e){    throw new ClassNotFoundException(name);   } } }

1. A multiple computer system having at least one application programrunning simultaneously on a plurality of computers interconnected by acommunications network, wherein a like plurality of substantiallyidentical objects are created, each in the corresponding computer andeach having a substantially identical name, and said system including alock means applicable to all said computers wherein any computer wishingto utilize a named object therein acquires an authorizing lock from saidlock means which permits said utilization and which prevents all theother computers from utilizing their corresponding named object untilsaid authorizing lock is relinquished.
 2. The system as claimed in claim1 wherein said lock means includes an acquire lock routine and a releaselock routine, and both said routines are included in modifications madeto said application program running on all said computers.
 3. The systemas claimed in claim 2 wherein said lock means further includes a sharedtable listing said named objects in use by any said computer, a lockstatus for each said object, and a queue of any pending lockacquisitions.
 4. The system as claimed in claim 3 wherein said lockmeans is located within an additional computer not running saidapplication program and connected to said communications network.
 5. Thesystem as claimed in claim 2 wherein each said application program ismodified before, during, or after loading by inserting a finalizationroutine to modify each instance at which said application program nolonger needs to refer to an object.
 6. The system as claimed in claim 3wherein the application program is modified in accordance with aprocedure selected from the group of procedures consisting ofre-compilation at loading, pre-compilation prior to loading, compilationprior to loading, just-in-time compilation, and re-compilation afterloading and before execution of the relevant portion of applicationprogram.
 7. The system as claimed in claim 2 wherein said modifiedapplication program is transferred to all said computers in accordancewith a procedure selected from the group consisting of master/slavetransfer, branched transfer and cascaded transfer.
 8. A plurality ofcomputers interconnected via a communications link and operating atleast one application program simultaneously wherein each said computerin operating said at least one application program utilizes an objectonly in local memory physically located in each said computer, thecontents of the local memory utilized by each said computer isfundamentally similar but not, at each instant, identical, and every oneof said computers has an acquire lock routine and a release lock routinewhich permit utilization of the local object only by one computer andeach of the remainder of said plurality of computers is locked out ofutilization of their corresponding object.
 9. The plurality of computersas claimed in claim 8 wherein the local memory capacity allocated to theor each said application program is substantially identical and thetotal memory capacity available to the or each said application programis said allocated memory capacity.
 10. The plurality of computers asclaimed in claim 8 wherein all said distribution update meanscommunicate via said communications link at a data transfer rate whichis substantially less than the local memory read rate.
 11. The pluralityof computers as claimed in claim 8 wherein at least some of saidcomputers are manufactured by different manufacturers and/or havedifferent operating systems.
 12. A method of running at least oneapplication program on a plurality of computers simultaneously, saidcomputers being interconnected by means of a communications network,said method comprising the steps of: (i) creating a like plurality ofsubstantially identical objects each in the corresponding computer andeach having a substantially identical name, and (ii) requiring any ofsaid computers wishing to utilize a named object therein to acquire anauthorizing lock which permits said utilization and which prevents allthe other computers from utilizing their corresponding named objectuntil said authorizing lock is relinquished.
 13. A method as claimed inclaim 12 including the further step of: (iii) providing each saidcomputer with a distributed run time means to communicate between saidcomputers via said communications network.
 14. A method as claimed inclaim 13 including the further step of: (iv) providing a shared tableaccessible by each said distributed run time means and in which isstored the identity of any computer which currently has to access anobject, together with the identity of the object.
 15. A method asclaimed in claim 14 including the further step of: (v) associating acounter means with said shared table, said counter means storing a countof the number of said computers which seek access to said object.
 16. Amethod as claimed in claim 15 including the further step of: (vi)providing an additional computer on which said shared program does notrun and which hosts said shared table and counter, said additionalcomputer being connected to said communications network.
 17. A method ofensuring consistent synchronization of an application program to be runsimultaneously on a plurality of computers interconnected via acommunications network, said method comprising the steps of: (i)scrutinizing said application program at, or prior to, or after loadingto detect each program step defining an synchronization routine, and(ii) modifying said synchronization routine to ensure utilization of anobject by only one computer and preventing all the remaining computersfrom simultaneously utilizing their corresponding objects.
 18. Themethod claimed in claim 17 wherein step (ii) comprises the steps of:(iii) loading and executing said synchronization routine on one of saidcomputers, (iv) modifying said synchronization routine by said onecomputer, and (v) transferring said modified synchronization routine toeach of the remaining computers.
 19. The method as claimed in claim 18wherein said modified synchronization routine is supplied by said onecomputer direct to each of said remaining computers.
 20. The method asclaimed in claim 18 wherein said modified synchronization routine issupplied in cascade fashion from said one computer sequentially to eachof said remaining computers.
 21. The method claimed in claim 17 whereinstep (ii) comprises the steps of: (vi) loading and modifying saidsynchronization routine on one of said computers, (vii) said onecomputer sending said unmodified synchronization routine to each of theremaining computers, and (viii) each of said remaining computersmodifying said synchronization routine after receipt of same.
 22. Themethod claimed in claim 21 wherein said unmodified synchronizationroutine is supplied by said one computer directly to each of saidremaining computers.
 23. The method claimed in claim 21 wherein saidunmodified synchronization routine is supplied in cascade fashion fromsaid one computer sequentially to each of said remaining computers. 24.The method as claimed in claim 17 including the further step of: (ix)modifying said application program utilizing a procedure selected fromthe group of procedures consisting of re-compilation at loading,pre-compilation prior to loading, compilation prior to loading,just-in-time compilation, and re-compilation after loading and beforeexecution of the relevant portion of application program.
 25. The methodas claimed in claim 17 including the further step of: (x) transferringthe modified application program to all said computers utilizing aprocedure selected from the group consisting of master/slave transfer,branched transfer and cascaded transfer.
 26. In a multiple threadprocessing computer operation in which individual threads of a singleapplication program are simultaneously being processed each on acorresponding one of a plurality of computers interconnected via acommunications link, and in which objects in local memory physicallyassociated with the computer processing each thread have correspondingobjects in the local memory of each other said computer, the improvementcomprising permitting only one of said computers to utilize an objectand preventing all the remaining computers from simultaneously utilizingtheir corresponding object.
 27. The improvement as claimed in claim 26wherein an object residing in the memory associated with one said threadand to be utilized has its identity communicated by the computer of saidone thread to a shared table accessible by all other said computers. 28.The improvement as claimed in claim 26 wherein an object residing in thememory associated with one said thread and to be utilized has itsidentity transmitted to the computer associated with another said threadand is transmitted thereby to a shared table accessible by all saidother computers.
 29. A computer program product comprising a set ofprogram instructions stored in a storage medium and operable to permit aplurality of computers to carry out the method as claimed in claim 12 or17.
 30. A plurality of computers interconnected via a communicationnetwork and operable to ensure consistent initialization of anapplication program running simultaneously of said computers, saidcomputers being programmed to carry out the method as claimed in claim12 or 17 or being loaded with the computer program product as claimed inclaim 29.